declare module "postprocessing" {
	import {
		Vector2,
		WebGLRenderer,
		Camera,
		PerspectiveCamera,
		Texture,
		Material,
		WebGLRenderTarget,
		Scene,
		Uniform,
		Object3D,
		Vector3,
		ShaderMaterial,
		DataTexture,
		Mesh,
		Points,
		Loader,
		DepthPackingStrategies,
		DepthModes,
		EventDispatcher,
		Color,
		ColorSpace,
		Data3DTexture,
		BaseEvent,
		CanvasTexture
	} from "three";

	/**
	 * Common events.
	 */

	export interface BaseEventMap {

		change: BaseEvent;

	}

	/**
	 * A color channel enumeration.
	 *
	 * @type {Object}
	 * @property {Number} RED - Red.
	 * @property {Number} GREEN - Green.
	 * @property {Number} BLUE - Blue.
	 * @property {Number} ALPHA - Alpha.
	 */
	export enum ColorChannel {
		RED,
		GREEN,
		BLUE,
		ALPHA,
	}

	/**
	 * The Disposable contract.
	 *
	 * Implemented by objects that can free internal resources.
	 *
	 * @interface
	 */
	export interface Disposable {

		/**
		 * Frees internal resources.
		 */
		dispose(): void;

	}

	/**
	 * The initializable contract.
	 *
	 * Implemented by objects that can be initialized.
	 *
	 * @interface
	 */
	export interface Initializable {

		/**
		 * Performs initialization tasks.
		 *
		 * @param {WebGLRenderer} renderer - A renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

	}

	/**
	 * A Gauss kernel.
	 *
	 * Based on https://github.com/Jam3/glsl-fast-gaussian-blur.
	 */
	export class GaussKernel {

		/**
		 * Constructs a new Gauss kernel.
		 *
		 * @param kernelSize - The kernel size. Should be an odd number in the range [3, 1020].
		 * @param [edgeBias=2] - Determines how many edge coefficients should be cut off for increased accuracy.
		 */
		constructor(kernelSize: number, edgeBias: number);

	}
	/**
	 * An adaptive luminance shader material.
	 */
	export class AdaptiveLuminanceMaterial extends ShaderMaterial {

		/**
		 * Constructs a new adaptive luminance material.
		 */
		constructor();
		/**
		 * The primary luminance buffer that contains the downsampled average luminance.
		 *
		 * @type {Texture}
		 */
		set luminanceBuffer0(arg: Texture);
		/**
		 * Sets the primary luminance buffer that contains the downsampled average luminance.
		 *
		 * @deprecated Use luminanceBuffer0 instead.
		 * @param {Texture} value - The buffer.
		 */
		setLuminanceBuffer0(value: Texture): void;
		/**
		 * The secondary luminance buffer.
		 *
		 * @type {Texture}
		 */
		set luminanceBuffer1(arg: Texture);
		/**
		 * Sets the secondary luminance buffer.
		 *
		 * @deprecated Use luminanceBuffer1 instead.
		 * @param {Texture} value - The buffer.
		 */
		setLuminanceBuffer1(value: Texture): void;
		/**
		 * The 1x1 mipmap level.
		 *
		 * This level is used to identify the smallest mipmap of the primary luminance buffer.
		 *
		 * @type {Number}
		 */
		set mipLevel1x1(arg: number);
		/**
		 * Sets the 1x1 mipmap level.
		 *
		 * @deprecated Use mipLevel1x1 instead.
		 * @param {Number} value - The level.
		 */
		setMipLevel1x1(value: number): void;
		/**
		 * The delta time.
		 *
		 * @type {Number}
		 */
		set deltaTime(arg: number);
		/**
		 * Sets the delta time.
		 *
		 * @deprecated Use deltaTime instead.
		 * @param {Number} value - The delta time.
		 */
		setDeltaTime(value: number): void;
		set minLuminance(arg: number);
		/**
		 * The lowest possible luminance value.
		 *
		 * @type {Number}
		 */
		get minLuminance(): number;
		/**
		 * Returns the lowest possible luminance value.
		 *
		 * @deprecated Use minLuminance instead.
		 * @return {Number} The minimum luminance.
		 */
		getMinLuminance(): number;
		/**
		 * Sets the minimum luminance.
		 *
		 * @deprecated Use minLuminance instead.
		 * @param {Number} value - The minimum luminance.
		 */
		setMinLuminance(value: number): void;
		set adaptationRate(arg: number);
		/**
		 * The luminance adaptation rate.
		 *
		 * @type {Number}
		 */
		get adaptationRate(): number;
		/**
		 * Returns the luminance adaptation rate.
		 *
		 * @deprecated Use adaptationRate instead.
		 * @return {Number} The adaptation rate.
		 */
		getAdaptationRate(): number;
		/**
		 * Sets the luminance adaptation rate.
		 *
		 * @deprecated Use adaptationRate instead.
		 * @param {Number} value - The adaptation rate.
		 */
		setAdaptationRate(value: number): void;

	}

	/**
	 * A bokeh disc blur material.
	 *
	 * This material should be applied twice in a row, with `fill` mode enabled for the second pass. Enabling the
	 * `foreground` option causes the shader to combine the near and far CoC values around foreground objects.
	 *
	 * @implements {Resizable}
	 */
	export class BokehMaterial extends ShaderMaterial implements Resizable {

		/**
		 * Constructs a new bokeh material.
		 *
		 * @param {Boolean} [fill=false] - Enables or disables the bokeh highlight fill mode.
		 * @param {Boolean} [foreground=false] - Determines whether this material will be applied to foreground colors.
		 */
		constructor(fill?: boolean, foreground?: boolean);
		/**
		 * The input buffer.
		 *
		 * @type {Texture}
		 */
		set inputBuffer(arg: Texture);
		/**
		 * Sets the input buffer.
		 *
		 * @deprecated Use inputBuffer instead.
		 * @param {Texture} value - The buffer.
		 */
		setInputBuffer(value: Texture): void;
		/**
		 * The circle of confusion buffer.
		 *
		 * @type {Texture}
		 */
		set cocBuffer(arg: Texture);
		/**
		 * Sets the circle of confusion buffer.
		 *
		 * @deprecated Use cocBuffer instead.
		 * @param {Texture} value - The buffer.
		 */
		setCoCBuffer(value: Texture): void;
		set scale(arg: number);
		/**
		 * The blur scale.
		 *
		 * @type {Number}
		 */
		get scale(): number;
		/**
		 * Returns the blur scale.
		 *
		 * @deprecated Use scale instead.
		 * @return {Number} The scale.
		 */
		getScale(value: number): number;
		/**
		 * Sets the blur scale.
		 *
		 * @deprecated Use scale instead.
		 * @param {Number} value - The scale.
		 */
		setScale(value: number): void;
		/**
		 * Sets the texel size.
		 *
		 * @deprecated Use setSize() instead.
		 * @param {Number} x - The texel width.
		 * @param {Number} y - The texel height.
		 */
		setTexelSize(x: number, y: number): void;
		/**
		 * Sets the size of this object.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	/**
	 * A Circle of Confusion shader material.
	 */
	export class CircleOfConfusionMaterial extends ShaderMaterial {

		/**
		 * Constructs a new CoC material.
		 *
		 * @param {Camera} camera - A camera.
		 */
		constructor(camera: Camera);
		/**
		 * The depth buffer.
		 *
		 * @type {Texture}
		 */
		set depthBuffer(arg: Texture);
		/**
		 * The depth packing strategy.
		 *
		 * @type {DepthPackingStrategies}
		 */
		set depthPacking(arg: DepthPackingStrategies);
		/**
		 * Sets the depth buffer.
		 *
		 * @deprecated Use depthBuffer and depthPacking instead.
		 * @param {Texture} buffer - The depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing strategy.
		 */
		setDepthBuffer(
			buffer: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		set focusDistance(arg: number);
		/**
		 * The focus distance. Range: [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get focusDistance(): number;
		/**
		 * Returns the focus distance.
		 *
		 * @deprecated Use focusDistance instead.
		 * @return {Number} The focus distance.
		 */
		getFocusDistance(value: number): number;
		/**
		 * Sets the focus distance.
		 *
		 * @deprecated Use focusDistance instead.
		 * @param {Number} value - The focus distance.
		 */
		setFocusDistance(value: number): void;
		set focalLength(arg: number);
		/**
		 * The focal length.
		 *
		 * @deprecated Renamed to focusRange.
		 * @type {Number}
		 */
		get focalLength(): number;
		/**
		 * Returns the focal length.
		 *
		 * @deprecated Use focusRange instead.
		 * @return {Number} The focal length.
		 */
		getFocalLength(value: number): number;
		/**
		 * Sets the focal length.
		 *
		 * @deprecated Use focusRange instead.
		 * @param {Number} value - The focal length.
		 */
		setFocalLength(value: number): void;
		/**
		 * Adopts the settings of the given camera.
		 *
		 * @param {Camera} camera - A camera.
		 */
		adoptCameraSettings(camera: Camera): void;

		/**
		 * The focus distance in world units.
		 *
		 * @type {Number}
		 */
		get worldFocusDistance(): number;
		set worldFocusDistance(value: number);

		/**
		 * The focus range. Range: [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get focusRange(): number;
		set focusRange(value: number);

		/**
		 * The focus range in world units.
		 *
		 * @type {Number}
		 */
		get worldFocusRange(): number;
		set worldFocusRange(value: number);

	}

	/**
	 * A blur kernel size enumeration.
	 *
	 * @type {Object}
	 * @property {Number} VERY_SMALL - A very small kernel that matches a 7x7 Gaussian blur kernel.
	 * @property {Number} SMALL - A small kernel that matches a 15x15 Gaussian blur kernel.
	 * @property {Number} MEDIUM - A medium sized kernel that matches a 23x23 Gaussian blur kernel.
	 * @property {Number} LARGE - A large kernel that matches a 35x35 Gaussian blur kernel.
	 * @property {Number} VERY_LARGE - A very large kernel that matches a 63x63 Gaussian blur kernel.
	 * @property {Number} HUGE - A huge kernel that matches a 127x127 Gaussian blur kernel.
	 */
	export enum KernelSize {
		VERY_SMALL,
		SMALL,
		MEDIUM,
		LARGE,
		VERY_LARGE,
		HUGE,
	}

	/**
	 * A simple copy shader material.
	 */
	export class CopyMaterial extends ShaderMaterial {

		/**
		 * Constructs a new copy material.
		 */
		constructor();
		/**
		 * The input buffer.
		 *
		 * @type {Texture}
		 */
		set inputBuffer(arg: Texture);
		/**
		 * Sets the input buffer.
		 *
		 * @deprecated Use inputBuffer instead.
		 * @param {Number} value - The buffer.
		 */
		setInputBuffer(value: number): void;
		/**
		 * Returns the opacity.
		 *
		 * @deprecated Use opacity instead.
		 * @return {Number} The opacity.
		 */
		getOpacity(): number;
		/**
		 * Sets the opacity.
		 *
		 * @deprecated Use opacity instead.
		 * @param {Number} value - The opacity.
		 */
		setOpacity(value: number): void;

	}

	/**
	 * A depth comparison shader material.
	 */
	export class DepthComparisonMaterial extends ShaderMaterial {

		/**
		 * Constructs a new depth comparison material.
		 *
		 * @param {Texture} [depthTexture=null] - A depth texture.
		 * @param {PerspectiveCamera} [camera] - A camera.
		 */
		constructor(depthTexture?: Texture, camera?: PerspectiveCamera);
		/**
		 * The depth buffer.
		 *
		 * @type {Texture}
		 */
		set depthBuffer(arg: Texture);
		/**
		 * The depth packing strategy.
		 *
		 * @type {DepthPackingStrategies}
		 */
		set depthPacking(arg: DepthPackingStrategies);
		/**
		 * Sets the depth buffer.
		 *
		 * @deprecated Use depthBuffer and depthPacking instead.
		 * @param {Texture} buffer - The depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=RGBADepthPacking] - The depth packing strategy.
		 */
		setDepthBuffer(
			buffer: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * Adopts the settings of the given camera.
		 *
		 * @param {Camera} camera - A camera.
		 */
		adoptCameraSettings(camera: Camera): void;

	}

	/**
	 * An enumeration of depth copy modes.
	 *
	 * @type {Object}
	 * @property {Number} FULL - Copies the full depth texture every frame.
	 * @property {Number} SINGLE - Copies a single texel from the depth texture on demand.
	 */
	export enum DepthCopyMode {
		FULL,
		SINGLE,
	}

	/**
	 * A depth copy shader material.
	 */
	export class DepthCopyMaterial extends ShaderMaterial {

		/**
		 * Constructs a new depth copy material.
		 */
		constructor();
		/**
		 * The input depth buffer.
		 *
		 * @type {Texture}
		 */
		set depthBuffer(arg: Texture);
		/**
		 * The input depth packing strategy.
		 *
		 * @type {DepthPackingStrategies}
		 */
		set inputDepthPacking(arg: DepthPackingStrategies);
		set outputDepthPacking(arg: DepthPackingStrategies);
		/**
		 * The output depth packing strategy.
		 *
		 * @type {DepthPackingStrategies}
		 */
		get outputDepthPacking(): DepthPackingStrategies;
		/**
		 * Sets the input depth buffer.
		 *
		 * @deprecated Use depthBuffer and inputDepthPacking instead.
		 * @param {Texture} buffer - The depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing strategy.
		 */
		setDepthBuffer(
			buffer: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * Returns the current input depth packing strategy.
		 *
		 * @deprecated
		 * @return {DepthPackingStrategies} The input depth packing strategy.
		 */
		getInputDepthPacking(): DepthPackingStrategies;
		/**
		 * Sets the input depth packing strategy.
		 *
		 * @deprecated Use inputDepthPacking instead.
		 * @param {DepthPackingStrategies} value - The new input depth packing strategy.
		 */
		setInputDepthPacking(value: DepthPackingStrategies): void;
		/**
		 * Returns the current output depth packing strategy.
		 *
		 * @deprecated Use outputDepthPacking instead.
		 * @return {DepthPackingStrategies} The output depth packing strategy.
		 */
		getOutputDepthPacking(): DepthPackingStrategies;
		/**
		 * Sets the output depth packing strategy.
		 *
		 * @deprecated Use outputDepthPacking instead.
		 * @param {DepthPackingStrategies} value - The new output depth packing strategy.
		 */
		setOutputDepthPacking(value: DepthPackingStrategies): void;
		/**
		 * The screen space position used for single-texel copy operations.
		 *
		 * @type {Vector2}
		 */
		get texelPosition(): Vector2;
		/**
		 * Returns the screen space position used for single-texel copy operations.
		 *
		 * @deprecated Use texelPosition instead.
		 * @return {Vector2} The position.
		 */
		getTexelPosition(): Vector2;
		/**
		 * Sets the screen space position used for single-texel copy operations.
		 *
		 * @deprecated
		 * @param {Vector2} value - The position.
		 */
		setTexelPosition(value: Vector2): void;
		set mode(arg: DepthCopyMode);
		/**
		 * The depth copy mode.
		 *
		 * @type {DepthCopyMode}
		 */
		get mode(): DepthCopyMode;
		/**
		 * Returns the depth copy mode.
		 *
		 * @deprecated Use mode instead.
		 * @return {DepthCopyMode} The depth copy mode.
		 */
		getMode(): DepthCopyMode;
		/**
		 * Sets the depth copy mode.
		 *
		 * @deprecated Use mode instead.
		 * @param {DepthCopyMode} value - The new mode.
		 */
		setMode(value: DepthCopyMode): void;

	}

	/**
	 * A depth downsampling shader material.
	 *
	 * Based on an article by Eleni Maria Stea:
	 * https://eleni.mutantstargoat.com/hikiko/depth-aware-upsampling-6
	 *
	 * @implements {Resizable}
	 */
	export class DepthDownsamplingMaterial
		extends ShaderMaterial
		implements Resizable {

		/**
		 * Constructs a new depth downsampling material.
		 */
		constructor();
		/**
		 * The depth buffer.
		 *
		 * @type {Texture}
		 */
		set depthBuffer(arg: Texture);
		/**
		 * The depth packing strategy.
		 *
		 * @type {DepthPackingStrategies}
		 */
		set depthPacking(arg: DepthPackingStrategies);
		/**
		 * Sets the depth buffer.
		 *
		 * @deprecated Use depthBuffer and depthPacking instead.
		 * @param {Texture} buffer - The depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing strategy.
		 */
		setDepthBuffer(
			buffer: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * The normal buffer.
		 *
		 * @type {Texture}
		 */
		set normalBuffer(arg: Texture);
		/**
		 * Sets the normal buffer.
		 *
		 * @deprecated Use normalBuffer instead.
		 * @param {Texture} value - The normal buffer.
		 */
		setNormalBuffer(value: Texture): void;
		/**
		 * Sets the texel size.
		 *
		 * @deprecated Use setSize() instead.
		 * @param {Number} x - The texel width.
		 * @param {Number} y - The texel height.
		 */
		setTexelSize(x: number, y: number): void;
		/**
		 * Sets the size of this object.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	/**
	 * An enumeration of depth test strategies.
	 *
	 * @type {Object}
	 * @property {Number} DEFAULT - Perform depth test only.
	 * @property {Number} KEEP_MAX_DEPTH - Always keep max depth.
	 * @property {Number} DISCARD_MAX_DEPTH - Always discard max depth.
	 */
	export enum DepthTestStrategy {
		DEFAULT,
		KEEP_MAX_DEPTH,
		DISCARD_MAX_DEPTH,
	}

	/**
	 * A depth mask shader material.
	 *
	 * This material masks a color buffer by comparing two depth textures.
	 */
	export class DepthMaskMaterial extends ShaderMaterial {

		/**
		 * Constructs a new depth mask material.
		 */
		constructor();
		set depthMode(arg: DepthModes);
		/**
		 * The depth mode.
		 *
		 * @see https://threejs.org/docs/#api/en/constants/Materials
		 * @type {DepthModes}
		 */
		get depthMode(): DepthModes;
		/**
		 * The primary depth buffer.
		 *
		 * @type {Texture}
		 */
		set depthBuffer0(arg: Texture);
		/**
		 * The primary depth packing strategy.
		 *
		 * @type {DepthPackingStrategies}
		 */
		set depthPacking0(arg: DepthPackingStrategies);
		/**
		 * Sets the base depth buffer.
		 *
		 * @deprecated Use depthBuffer0 and depthPacking0 instead.
		 * @param {Texture} buffer - The depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing strategy.
		 */
		setDepthBuffer0(
			buffer: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * The secondary depth buffer.
		 *
		 * @type {Texture}
		 */
		set depthBuffer1(arg: Texture);
		/**
		 * The secondary depth packing strategy.
		 *
		 * @type {DepthPackingStrategies}
		 */
		set depthPacking1(arg: DepthPackingStrategies);
		/**
		 * Sets the depth buffer that will be compared with the base depth buffer.
		 *
		 * @deprecated Use depthBuffer1 and depthPacking1 instead.
		 * @param {Texture} buffer - The depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing strategy.
		 */
		setDepthBuffer1(
			buffer: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		set maxDepthStrategy(arg: DepthTestStrategy);
		/**
		 * The strategy for handling maximum depth.
		 *
		 * @type {DepthTestStrategy}
		 */
		get maxDepthStrategy(): DepthTestStrategy;
		set keepFar(arg: boolean);
		/**
		 * Indicates whether maximum depth values should be preserved.
		 *
		 * @type {Boolean}
		 * @deprecated Use maxDepthStrategy instead.
		 */
		get keepFar(): boolean;
		/**
		 * Returns the strategy for dealing with maximum depth values.
		 *
		 * @deprecated Use maxDepthStrategy instead.
		 * @return {DepthTestStrategy} The strategy.
		 */
		getMaxDepthStrategy(): DepthTestStrategy;
		/**
		 * Sets the strategy for dealing with maximum depth values.
		 *
		 * @deprecated Use maxDepthStrategy instead.
		 * @param {DepthTestStrategy} value - The strategy.
		 */
		setMaxDepthStrategy(value: DepthTestStrategy): void;
		set epsilon(arg: number);
		/**
		 * A small error threshold that is used for `EqualDepth` and `NotEqualDepth` tests. Default is `1e-5`.
		 *
		 * @type {Number}
		 */
		get epsilon(): number;
		/**
		 * Returns the current error threshold for depth comparisons. Default is `1e-5`.
		 *
		 * @deprecated Use epsilon instead.
		 * @return {Number} The error threshold.
		 */
		getEpsilon(): number;
		/**
		 * Sets the depth comparison error threshold.
		 *
		 * @deprecated Use epsilon instead.
		 * @param {Number} value - The new error threshold.
		 */
		setEpsilon(value: number): void;
		/**
		 * Returns the current depth mode.
		 *
		 * @deprecated Use depthMode instead.
		 * @return {DepthModes} The depth mode. Default is `LessDepth`.
		 */
		getDepthMode(): DepthModes;
		/**
		 * Sets the depth mode.
		 *
		 * @deprecated Use depthMode instead.
		 * @param {DepthModes} mode - The depth mode.
		 */
		setDepthMode(mode: DepthModes): void;

	}

	/**
	 * An enumeration of edge detection modes.
	 *
	 * @type {Object}
	 * @property {Number} DEPTH - Depth-based edge detection.
	 * @property {Number} LUMA - Luminance-based edge detection.
	 * @property {Number} COLOR - Chroma-based edge detection.
	 */
	export enum EdgeDetectionMode {
		DEPTH,
		LUMA,
		COLOR,
	}

	/**
	 * An enumeration of predication modes.
	 *
	 * @type {Object}
	 * @property {Number} DISABLED - No predicated thresholding.
	 * @property {Number} DEPTH - Depth-based predicated thresholding.
	 * @property {Number} CUSTOM - Predicated thresholding using a custom buffer.
	 */
	export enum PredicationMode {
		DISABLED,
		DEPTH,
		CUSTOM,
	}
	/**
	 * An edge detection material.
	 *
	 * Mainly used for Subpixel Morphological Anti-Aliasing.
	 *
	 * @implements {Resizable}
	 */
	export class EdgeDetectionMaterial
		extends ShaderMaterial
		implements Resizable {

		/**
		 * Constructs a new edge detection material.
		 *
		 * TODO Remove parameters.
		 * @param {Vector2} [texelSize] - The screen texel size.
		 * @param {EdgeDetectionMode} [mode=EdgeDetectionMode.COLOR] - The edge detection mode.
		 */
		constructor(texelSize?: Vector2, mode?: EdgeDetectionMode);
		set edgeDetectionMode(arg: EdgeDetectionMode);
		/**
		 * The edge detection mode.
		 *
		 * @type {EdgeDetectionMode}
		 */
		get edgeDetectionMode(): EdgeDetectionMode;
		/**
		 * The depth buffer.
		 *
		 * @type {Texture}
		 */
		set depthBuffer(arg: Texture);
		/**
		 * The depth packing strategy.
		 *
		 * @type {DepthPackingStrategies}
		 */
		set depthPacking(arg: DepthPackingStrategies);
		/**
		 * Sets the depth buffer.
		 *
		 * @deprecated Use depthBuffer and depthPacking instead.
		 * @param {Texture} buffer - The depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing strategy.
		 */
		setDepthBuffer(
			buffer: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * Returns the edge detection mode.
		 *
		 * @deprecated Use edgeDetectionMode instead.
		 * @return {EdgeDetectionMode} The mode.
		 */
		getEdgeDetectionMode(): EdgeDetectionMode;
		/**
		 * Sets the edge detection mode.
		 *
		 * @deprecated Use edgeDetectionMode instead.
		 * @param {EdgeDetectionMode} value - The edge detection mode.
		 */
		setEdgeDetectionMode(value: EdgeDetectionMode): void;
		set localContrastAdaptationFactor(arg: number);
		/**
		 * The local contrast adaptation factor. Has no effect if the edge detection mode is set to DEPTH. Default is 2.0.
		 *
		 * If a neighbor edge has _factor_ times bigger contrast than the current edge, the edge will be discarded.
		 *
		 * This allows to eliminate spurious crossing edges and is based on the fact that if there is too much contrast in a
		 * direction, the perceptual contrast in the other neighbors will be hidden.
		 *
		 * @type {Number}
		 */
		get localContrastAdaptationFactor(): number;
		/**
		 * Returns the local contrast adaptation factor.
		 *
		 * @deprecated Use localContrastAdaptationFactor instead.
		 * @return {Number} The factor.
		 */
		getLocalContrastAdaptationFactor(): number;
		/**
		 * Sets the local contrast adaptation factor. Has no effect if the edge detection mode is set to DEPTH.
		 *
		 * @deprecated Use localContrastAdaptationFactor instead.
		 * @param {Number} value - The local contrast adaptation factor. Default is 2.0.
		 */
		setLocalContrastAdaptationFactor(value: number): void;
		set edgeDetectionThreshold(arg: number);
		/**
		 * The edge detection threshold. Range: [0.0, 0.5].
		 *
		 * A lower value results in more edges being detected at the expense of performance.
		 *
		 * For luma- and chroma-based edge detection, 0.1 is a reasonable value and allows to catch most visible edges. 0.05
		 * is a rather overkill value that allows to catch 'em all. Darker scenes may require an even lower threshold.
		 *
		 * If depth-based edge detection is used, the threshold will depend on the scene depth.
		 *
		 * @type {Number}
		 */
		get edgeDetectionThreshold(): number;
		/**
		 * Returns the edge detection threshold.
		 *
		 * @deprecated Use edgeDetectionThreshold instead.
		 * @return {Number} The threshold.
		 */
		getEdgeDetectionThreshold(): number;
		/**
		 * Sets the edge detection threshold.
		 *
		 * @deprecated Use edgeDetectionThreshold instead.
		 * @param {Number} value - The edge detection threshold. Range: [0.0, 0.5].
		 */
		setEdgeDetectionThreshold(value: number): void;
		set predicationMode(arg: PredicationMode);
		/**
		 * The predication mode.
		 *
		 * Predicated thresholding allows to better preserve texture details and to improve edge detection using an additional
		 * buffer such as a light accumulation or depth buffer.
		 *
		 * @type {PredicationMode}
		 */
		get predicationMode(): PredicationMode;
		/**
		 * Returns the predication mode.
		 *
		 * @deprecated Use predicationMode instead.
		 * @return {PredicationMode} The mode.
		 */
		getPredicationMode(): PredicationMode;
		/**
		 * Sets the predication mode.
		 *
		 * @deprecated Use predicationMode instead.
		 * @param {PredicationMode} value - The predication mode.
		 */
		setPredicationMode(value: PredicationMode): void;
		/**
		 * The predication buffer.
		 *
		 * @type {Texture}
		 */
		set predicationBuffer(arg: Texture);
		/**
		 * Sets a custom predication buffer.
		 *
		 * @deprecated Use predicationBuffer instead.
		 * @param {Texture} value - The predication buffer.
		 */
		setPredicationBuffer(value: Texture): void;
		set predicationThreshold(arg: number);
		/**
		 * The predication threshold.
		 *
		 * @type {Number}
		 */
		get predicationThreshold(): number;
		/**
		 * Returns the predication threshold.
		 *
		 * @deprecated Use predicationThreshold instead.
		 * @return {Number} The threshold.
		 */
		getPredicationThreshold(): number;
		/**
		 * Sets the predication threshold.
		 *
		 * @deprecated Use predicationThreshold instead.
		 * @param {Number} value - The threshold.
		 */
		setPredicationThreshold(value: number): void;
		set predicationScale(arg: number);
		/**
		 * The predication scale. Range: [1.0, 5.0].
		 *
		 * Determines how much the edge detection threshold should be scaled when using predication.
		 *
		 * @type {Number}
		 */
		get predicationScale(): number;
		/**
		 * Returns the predication scale.
		 *
		 * @deprecated Use predicationScale instead.
		 * @return {Number} The scale.
		 */
		getPredicationScale(): number;
		/**
		 * Sets the predication scale.
		 *
		 * @deprecated Use predicationScale instead.
		 * @param {Number} value - The scale. Range: [1.0, 5.0].
		 */
		setPredicationScale(value: number): void;
		set predicationStrength(arg: number);
		/**
		 * The predication strength. Range: [0.0, 1.0].
		 *
		 * Determines how much the edge detection threshold should be decreased locally when using predication.
		 *
		 * @type {Number}
		 */
		get predicationStrength(): number;
		/**
		 * Returns the predication strength.
		 *
		 * @deprecated Use predicationStrength instead.
		 * @return {Number} The strength.
		 */
		getPredicationStrength(): number;
		/**
		 * Sets the predication strength.
		 *
		 * @deprecated Use predicationStrength instead.
		 * @param {Number} value - The strength. Range: [0.0, 1.0].
		 */
		setPredicationStrength(value: number): void;
		/**
		 * Sets the size of this object.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	export type ColorEdgesMaterial = EdgeDetectionMaterial;

	/**
	 * An effect material for compound shaders. Supports dithering.
	 *
	 * @implements {Resizable}
	 */
	export class EffectMaterial extends ShaderMaterial implements Resizable {

		/**
		 * An enumeration of shader code section placeholders used by the {@link EffectPass}.
		 *
		 * @type {Object}
		 * @property {String} FRAGMENT_HEAD - A placeholder for function and variable declarations inside the fragment shader.
		 * @property {String} FRAGMENT_MAIN_UV - A placeholder for UV transformations inside the fragment shader.
		 * @property {String} FRAGMENT_MAIN_IMAGE - A placeholder for color calculations inside the fragment shader.
		 * @property {String} VERTEX_HEAD - A placeholder for function and variable declarations inside the vertex shader.
		 * @property {String} VERTEX_MAIN_SUPPORT - A placeholder for supporting calculations inside the vertex shader.
		 */
		static get Section(): {
			FRAGMENT_HEAD: string;
			FRAGMENT_MAIN_UV: string;
			FRAGMENT_MAIN_IMAGE: string;
			VERTEX_HEAD: string;
			VERTEX_MAIN_SUPPORT: string;
		};

		/**
		 * Constructs a new effect material.
		 *
		 * @param {Map<String, String>} [shaderParts] - A collection of shader snippets. See {@link Section}.
		 * @param {Map<String, String>} [defines] - A collection of preprocessor macro definitions.
		 * @param {Map<String, Uniform>} [uniforms] - A collection of uniforms.
		 * @param {Camera} [camera] - A camera.
		 * @param {Boolean} [dithering=false] - Whether dithering should be enabled.
		 */
		constructor(
			shaderParts?: Map<string, string>,
			defines?: Map<string, string>,
			uniforms?: Map<string, Uniform>,
			camera?: Camera,
			dithering?: boolean
		);

		/**
		 * The input buffer.
		 *
		 * @type {Texture}
		 */
		set inputBuffer(arg: Texture);
		/**
		 * Sets the input buffer.
		 *
		 * @deprecated Use inputBuffer instead.
		 * @param {Texture} value - The input buffer.
		 */
		setInputBuffer(value: Texture): void;
		set depthBuffer(arg: Texture);
		/**
		 * The depth buffer.
		 *
		 * @type {Texture}
		 */
		get depthBuffer(): Texture;
		set depthPacking(arg: DepthPackingStrategies);
		/**
		 * The depth packing strategy.
		 *
		 * @type {DepthPackingStrategies}
		 */
		get depthPacking(): DepthPackingStrategies;
		/**
		 * Sets the depth buffer.
		 *
		 * @deprecated Use depthBuffer and depthPacking instead.
		 * @param {Texture} buffer - The depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing strategy.
		 */
		setDepthBuffer(
			buffer: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * Sets the shader parts.
		 *
		 * @param {Map<String, String>} shaderParts - A collection of shader snippets. See {@link Section}.
		 * @return {EffectMaterial} This material.
		 */
		setShaderParts(shaderParts: Map<string, string>): EffectMaterial;
		/**
		 * Sets the shader macros.
		 *
		 * @param {Map<String, String>} defines - A collection of preprocessor macro definitions.
		 * @return {EffectMaterial} This material.
		 */
		setDefines(defines: Map<string, string>): EffectMaterial;
		/**
		 * Sets the shader uniforms.
		 *
		 * @param {Map<String, Uniform>} uniforms - A collection of uniforms.
		 * @return {EffectMaterial} This material.
		 */
		setUniforms(uniforms: Map<string, Uniform>): EffectMaterial;
		/**
		 * Sets the required shader extensions.
		 *
		 * @param {Set<WebGLExtension>} extensions - A collection of extensions.
		 * @return {EffectMaterial} This material.
		 */
		setExtensions(extensions: Set<WebGLExtension>): EffectMaterial;
		set encodeOutput(arg: boolean);
		/**
		 * Indicates whether output encoding is enabled.
		 *
		 * @type {Boolean}
		 */
		get encodeOutput(): boolean;
		/**
		 * Indicates whether output encoding is enabled.
		 *
		 * @deprecated Use encodeOutput instead.
		 * @return {Boolean} Whether output encoding is enabled.
		 */
		isOutputEncodingEnabled(): boolean;
		/**
		 * Enables or disables output encoding.
		 *
		 * @deprecated Use encodeOutput instead.
		 * @param {Boolean} value - Whether output encoding should be enabled.
		 */
		setOutputEncodingEnabled(value: boolean): void;
		set time(arg: number);
		/**
		 * The time in seconds.
		 *
		 * @type {Number}
		 */
		get time(): number;
		/**
		 * Sets the delta time.
		 *
		 * @deprecated Use time instead.
		 * @param {Number} value - The delta time in seconds.
		 */
		setDeltaTime(value: number): void;
		/**
		 * Adopts the settings of the given camera.
		 *
		 * @param {Camera} camera - A camera.
		 */
		adoptCameraSettings(camera: Camera): void;
		/**
		 * Sets the resolution.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	/**
	 * An enumeration of shader code placeholders used by the {@link EffectPass}.
	 * @property FRAGMENT_HEAD - A placeholder for function and variable declarations inside the fragment shader.
	 * @property FRAGMENT_MAIN_UV - A placeholder for UV transformations inside the fragment shader.
	 * @property FRAGMENT_MAIN_IMAGE - A placeholder for color calculations inside the fragment shader.
	 * @property VERTEX_HEAD - A placeholder for function and variable declarations inside the vertex shader.
	 * @property VERTEX_MAIN_SUPPORT - A placeholder for supporting calculations inside the vertex shader.
	 * @deprecated Use EffectMaterial.Section instead.
	 */
	export const Section: {
		FRAGMENT_HEAD: string;
		FRAGMENT_MAIN_UV: string;
		FRAGMENT_MAIN_IMAGE: string;
		VERTEX_HEAD: string;
		VERTEX_MAIN_SUPPORT: string;
	};

	/**
	 * A crepuscular rays shader material.
	 *
	 * References:
	 *
	 * Thibaut Despoulain, 2012:
	 *	[(WebGL) Volumetric Light Approximation in Three.js](
	 *	http://bkcore.com/blog/3d/webgl-three-js-volumetric-light-godrays.html)
	 *
	 * Nvidia, GPU Gems 3, 2008:
	 *	[Chapter 13. Volumetric Light Scattering as a Post-Process](
	 *	https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch13.html)
	 *
	 * @todo Remove dithering code from fragment shader.
	 */
	export class GodRaysMaterial extends ShaderMaterial {

		/**
		 * Constructs a new god rays material.
		 *
		 * TODO Remove lightPosition param.
		 * @param {Vector2} lightPosition - Deprecated.
		 */
		constructor(lightPosition: Vector2);
		/**
		 * The input buffer.
		 *
		 * @type {Texture}
		 */
		set inputBuffer(arg: Texture);
		/**
		 * Sets the input buffer.
		 *
		 * @deprecated Use inputBuffer instead.
		 * @param {Texture} value - The input buffer.
		 */
		setInputBuffer(value: Texture): void;
		/**
		 * The screen space position of the light source.
		 *
		 * @type {Vector2}
		 */
		get lightPosition(): Vector2;
		/**
		 * Returns the screen space position of the light source.
		 *
		 * @deprecated Use lightPosition instead.
		 * @return {Vector2} The position.
		 */
		getLightPosition(): Vector2;
		/**
		 * Sets the screen space position of the light source.
		 *
		 * @deprecated Use lightPosition instead.
		 * @param {Vector2} value - The position.
		 */
		setLightPosition(value: Vector2): void;
		set density(arg: number);
		/**
		 * The density.
		 *
		 * @type {Number}
		 */
		get density(): number;
		/**
		 * Returns the density.
		 *
		 * @deprecated Use density instead.
		 * @return {Number} The density.
		 */
		getDensity(): number;
		/**
		 * Sets the density.
		 *
		 * @deprecated Use density instead.
		 * @param {Number} value - The density.
		 */
		setDensity(value: number): void;
		set decay(arg: number);
		/**
		 * The decay.
		 *
		 * @type {Number}
		 */
		get decay(): number;
		/**
		 * Returns the decay.
		 *
		 * @deprecated Use decay instead.
		 * @return {Number} The decay.
		 */
		getDecay(): number;
		/**
		 * Sets the decay.
		 *
		 * @deprecated Use decay instead.
		 * @param {Number} value - The decay.
		 */
		setDecay(value: number): void;
		set weight(arg: number);
		/**
		 * The weight.
		 *
		 * @type {Number}
		 */
		get weight(): number;
		/**
		 * Returns the weight.
		 *
		 * @deprecated Use weight instead.
		 * @return {Number} The weight.
		 */
		getWeight(): number;
		/**
		 * Sets the weight.
		 *
		 * @deprecated Use weight instead.
		 * @param {Number} value - The weight.
		 */
		setWeight(value: number): void;
		set exposure(arg: number);
		/**
		 * The exposure.
		 *
		 * @type {Number}
		 */
		get exposure(): number;
		/**
		 * Returns the exposure.
		 *
		 * @deprecated Use exposure instead.
		 * @return {Number} The exposure.
		 */
		getExposure(): number;
		/**
		 * Sets the exposure.
		 *
		 * @deprecated Use exposure instead.
		 * @param {Number} value - The exposure.
		 */
		setExposure(value: number): void;
		set maxIntensity(arg: number);
		/**
		 * The maximum light intensity.
		 *
		 * @type {Number}
		 */
		get maxIntensity(): number;
		/**
		 * Returns the maximum light intensity.
		 *
		 * @deprecated Use maxIntensity instead.
		 * @return {Number} The maximum light intensity.
		 */
		getMaxIntensity(): number;
		/**
		 * Sets the maximum light intensity.
		 *
		 * @deprecated Use maxIntensity instead.
		 * @param {Number} value - The maximum light intensity.
		 */
		setMaxIntensity(value: number): void;
		set samples(arg: number);
		/**
		 * The amount of samples per pixel.
		 *
		 * @type {Number}
		 */
		get samples(): number;
		/**
		 * Returns the amount of samples per pixel.
		 *
		 * @deprecated Use samples instead.
		 * @return {Number} The sample count.
		 */
		getSamples(): number;
		/**
		 * Sets the amount of samples per pixel.
		 *
		 * @deprecated Use samples instead.
		 * @param {Number} value - The sample count.
		 */
		setSamples(value: number): void;

	}

	/**
	 * A box blur material.
	 *
	 * @implements {Resizable}
	 */

	export class BoxBlurMaterial extends ShaderMaterial {}

	/**
	 * A box blur pass.
	 */

	export class BoxBlurPass extends Pass {

		/**
		 * Constructs a new box blur pass.
		 *
		 * @param {Object} [options] - The options.
		 * @param {Number} [options.kernelSize=5] - The kernel size.
		 * @param {Number} [options.iterations=1] - The amount of times the blur should be applied.
		 * @param {Number} [options.bilateral=false] - Enables or disables bilateral blurring.
		 * @param {Number} [options.resolutionScale=1.0] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 */

		constructor(
			{
				kernelSize,
				iterations,
				bilateral,
				resolutionScale,
				resolutionX,
				resolutionY
			}?: {
				kernelSize?: number;
				iterations?: number;
				bilateral?: boolean;
				resolutionScale?: number;
				resolutionX?: number;
				resolutionY?: number;
			}
		);

	}

	/**
	 * An optimized Gaussian convolution shader material.
	 *
	 * References:
	 *
	 * Filip Strugar, Intel, 2014: [An investigation of fast real-time GPU-based image blur algorithms](
	 * https://www.intel.com/content/www/us/en/developer/articles/technical/an-investigation-of-fast-real-time-gpu-based-image-blur-algorithms.html)
	 *
	 * @implements {Resizable}
	 */

	export class GaussianBlurMaterial extends ShaderMaterial {

		/**
		 * Constructs a new convolution material.
		 *
		 * @param {Object} [options] - The options.
		 * @param {Number} [options.kernelSize=35] - The kernel size.
		 */
		constructor(
			{
				kernelSize
			}?: {
				kernelSize?: number;
			}
		);

	}

	/**
	 * A Gaussian blur pass.
	 */

	export class GaussianBlurPass extends Pass {

		/**
		 * Constructs a new Gaussian blur pass.
		 *
		 * @param {Object} [options] - The options.
		 * @param {Number} [options.kernelSize=35] - The kernel size. Should be an odd number in the range [3, 1020].
		 * @param {Number} [options.iterations=1] - The amount of times the blur should be applied.
		 * @param {Number} [options.resolutionScale=1.0] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 */

		constructor(
			{
				kernelSize,
				iterations,
				resolutionScale,
				resolutionX,
				resolutionY
			}?: {
				kernelSize?: number;
				iterations?: number;
				resolutionScale?: number;
				resolutionX?: number;
				resolutionY?: number;
			}
		);

	}

	/**
	 * An optimised convolution shader material.
	 *
	 * Based on the GDC2003 Presentation by Masaki Kawase, Bunkasha Games:
	 *	Frame Buffer Postprocessing Effects in DOUBLE-S.T.E.A.L (Wreckless)
	 * and an article by Filip Strugar, Intel:
	 *	An investigation of fast real-time GPU-based image blur algorithms
	 *
	 * Further modified according to Apple's [Best Practices for Shaders](https://goo.gl/lmRoM5).
	 *
	 * @todo Remove dithering code from fragment shader.
	 * @implements {Resizable}
	 */
	export class KawaseBlurMaterial extends ShaderMaterial implements Resizable {

		/**
		 * Constructs a new convolution material.
		 *
		 * TODO Remove texelSize param.
		 * @param {Vector2} [texelSize] - Deprecated.
		 */
		constructor(texelSize?: Vector2);
		/**
		 * The input buffer.
		 *
		 * @type {Texture}
		 */
		set inputBuffer(arg: Texture);
		/**
		 * Sets the input buffer.
		 *
		 * @deprecated Use inputBuffer instead.
		 * @param {Texture} value - The input buffer.
		 */
		setInputBuffer(value: Texture): void;
		set scale(arg: number);
		/**
		 * The blur scale.
		 *
		 * @type {Number}
		 */
		get scale(): number;
		/**
		 * Returns the blur scale.
		 *
		 * @deprecated Use scale instead.
		 * @return {Number} The scale.
		 */
		getScale(): number;
		/**
		 * Sets the blur scale.
		 *
		 * @deprecated Use scale instead.
		 * @param {Number} value - The scale.
		 */
		setScale(value: number): void;
		/**
		 * Returns the kernel.
		 *
		 * @return {Float32Array} The kernel.
		 * @deprecated Implementation detail, removed with no replacement.
		 */
		getKernel(): Float32Array;
		set kernel(arg: number);
		/**
		 * The current kernel.
		 *
		 * @type {Number}
		 */
		get kernel(): number;
		/**
		 * Sets the current kernel.
		 *
		 * @deprecated Use kernel instead.
		 * @param {Number} value - The kernel.
		 */
		setKernel(value: number): void;
		/**
		 * Sets the texel size.
		 *
		 * @deprecated Use setSize() instead.
		 * @param {Number} x - The texel width.
		 * @param {Number} y - The texel height.
		 */
		setTexelSize(x: number, y: number): void;
		/**
		 * Sets the size of this object.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	export type ConvolutionMaterial = KawaseBlurMaterial;

	/**
	 * A luminance shader material.
	 *
	 * This shader produces a greyscale luminance map that describes the absolute amount of light emitted by a scene. It can
	 * also be configured to output colors that are scaled with their respective luminance value. Additionally, a range may
	 * be provided to mask out undesired texels.
	 *
	 * The alpha channel always contains the luminance value.
	 *
	 * On luminance coefficients:
	 *	http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html#RTFToC9
	 *
	 * Coefficients for different color spaces:
	 *	https://hsto.org/getpro/habr/post_images/2ab/69d/084/2ab69d084f9a597e032624bcd74d57a7.png
	 *
	 * Luminance range reference:
	 *	https://cycling74.com/2007/05/23/your-first-shader/#.Vty9FfkrL4Z
	 */
	export class LuminanceMaterial extends ShaderMaterial {

		/**
		 * Constructs a new luminance material.
		 *
		 * @param {Boolean} [colorOutput=false] - Defines whether the shader should output colors scaled with their luminance value.
		 * @param {Vector2} [luminanceRange] - If provided, the shader will mask out texels that aren't in the specified luminance range.
		 */
		constructor(colorOutput?: boolean, luminanceRange?: Vector2);
		set colorOutput(arg: boolean);
		/**
		 * Indicates whether color output is enabled.
		 *
		 * @type {Boolean}
		 */
		get colorOutput(): boolean;
		set luminanceRange(arg: boolean);
		/**
		 * The luminance range. Set to null to disable.
		 *
		 * @type {Boolean}
		 */
		get luminanceRange(): boolean;
		/**
		 * The input buffer.
		 *
		 * @type {Texture}
		 */
		set inputBuffer(arg: Texture);
		/**
		 * Sets the input buffer.
		 *
		 * @deprecated Use inputBuffer instead.
		 * @param {Texture} value - The input buffer.
		 */
		setInputBuffer(value: Texture): void;
		set threshold(arg: number);
		/**
		 * The luminance threshold.
		 *
		 * @type {Number}
		 */
		get threshold(): number;
		/**
		 * Returns the luminance threshold.
		 *
		 * @deprecated Use threshold instead.
		 * @return {Number} The threshold.
		 */
		getThreshold(): number;
		/**
		 * Sets the luminance threshold.
		 *
		 * @deprecated Use threshold instead.
		 * @param {Number} value - The threshold.
		 */
		setThreshold(value: number): void;
		set smoothing(arg: number);
		/**
		 * The luminance threshold smoothing.
		 *
		 * @type {Number}
		 */
		get smoothing(): number;
		/**
		 * Returns the luminance threshold smoothing factor.
		 *
		 * @deprecated Use smoothing instead.
		 * @return {Number} The smoothing factor.
		 */
		getSmoothingFactor(): number;
		/**
		 * Sets the luminance threshold smoothing factor.
		 *
		 * @deprecated Use smoothing instead.
		 * @param {Number} value - The smoothing factor.
		 */
		setSmoothingFactor(value: number): void;
		set useThreshold(arg: boolean);
		/**
		 * Indicates whether the luminance threshold is enabled.
		 *
		 * @type {Boolean}
		 * @deprecated Adjust the threshold or smoothing factor instead.
		 */
		get useThreshold(): boolean;
		/**
		 * Indicates whether color output is enabled.
		 *
		 * @deprecated Use colorOutput instead.
		 * @return {Boolean} Whether color output is enabled.
		 */
		isColorOutputEnabled(): boolean;
		/**
		 * Enables or disables color output.
		 *
		 * @deprecated Use colorOutput instead.
		 * @param {Boolean} value - Whether color output should be enabled.
		 */
		setColorOutputEnabled(value: boolean): void;
		set useRange(arg: boolean);
		/**
		 * Indicates whether luminance masking is enabled.
		 *
		 * @type {Boolean}
		 * @deprecated
		 */
		get useRange(): boolean;
		/**
		 * Returns the current luminance range.
		 *
		 * @deprecated Use luminanceRange instead.
		 * @return {Vector2} The luminance range.
		 */
		getLuminanceRange(): Vector2;
		/**
		 * Sets a luminance range. Set to null to disable.
		 *
		 * @deprecated Use luminanceRange instead.
		 * @param {Vector2} value - The luminance range.
		 */
		setLuminanceRange(value: Vector2): void;

	}

	/**
	 * A mask function enumeration.
	 *
	 * @type {Object}
	 * @property {Number} DISCARD - Discards elements when the respective mask value is zero.
	 * @property {Number} MULTIPLY - Multiplies the input buffer with the mask texture.
	 * @property {Number} MULTIPLY_RGB_SET_ALPHA - Multiplies the input RGB values with the mask and sets alpha to the mask value.
	 * @property {Number} MULTIPLY_RGB - Multiplies the input RGB values with the mask and keeps the original alpha.
	 */
	export enum MaskFunction {
		DISCARD,
		MULTIPLY,
		MULTIPLY_RGB_SET_ALPHA,
		MULTIPLY_RGB
	}

	/**
	 * A mask shader material.
	 *
	 * This material applies a mask texture to a buffer.
	 */
	export class MaskMaterial extends ShaderMaterial {

		/**
		 * Constructs a new mask material.
		 *
		 * @param {Texture} [maskTexture] - The mask texture.
		 */
		constructor(maskTexture?: Texture);
		/**
		 * The input buffer.
		 *
		 * @type {Texture}
		 */
		set inputBuffer(arg: Texture);
		/**
		 * Sets the input buffer.
		 *
		 * @deprecated Use inputBuffer instead.
		 * @param {Texture} value - The input buffer.
		 */
		setInputBuffer(value: Texture): void;
		/**
		 * The mask texture.
		 *
		 * @type {Texture}
		 */
		set maskTexture(arg: Texture);
		/**
		 * Sets the mask texture.
		 *
		 * @deprecated Use maskTexture instead.
		 * @param {Texture} value - The texture.
		 */
		setMaskTexture(value: Texture): void;
		/**
		 * Sets the color channel to use for masking. Default is `ColorChannel.RED`.
		 *
		 * @type {ColorChannel}
		 */
		set colorChannel(arg: ColorChannel);
		/**
		 * Sets the color channel to use for masking. Default is `ColorChannel.RED`.
		 *
		 * @deprecated Use colorChannel instead.
		 * @param {ColorChannel} value - The channel.
		 */
		setColorChannel(value: ColorChannel): void;
		/**
		 * The masking technique. Default is `MaskFunction.DISCARD`.
		 *
		 * @type {MaskFunction}
		 */
		set maskFunction(arg: MaskFunction);
		/**
		 * Sets the masking technique. Default is `MaskFunction.DISCARD`.
		 *
		 * @deprecated Use maskFunction instead.
		 * @param {MaskFunction} value - The function.
		 */
		setMaskFunction(value: MaskFunction): void;
		set inverted(arg: boolean);
		/**
		 * Indicates whether the masking is inverted.
		 *
		 * @type {Boolean}
		 */
		get inverted(): boolean;
		/**
		 * Indicates whether the masking is inverted.
		 *
		 * @deprecated Use inverted instead.
		 * @return {Boolean} Whether the masking is inverted.
		 */
		isInverted(): boolean;
		/**
		 * Determines whether the masking should be inverted.
		 *
		 * @deprecated Use inverted instead.
		 * @param {Boolean} value - Whether the masking should be inverted.
		 */
		setInverted(value: boolean): void;
		set strength(arg: number);
		/**
		 * The current mask strength.
		 *
		 * Individual mask values will be clamped to [0.0, 1.0]. Has no effect when the mask function is set to `DISCARD`.
		 *
		 * @type {Number}
		 */
		get strength(): number;
		/**
		 * Returns the current mask strength.
		 *
		 * @deprecated Use strength instead.
		 * @return {Number} The mask strength.
		 */
		getStrength(): number;
		/**
		 * Sets the mask strength.
		 *
		 * Has no effect when the mask function is set to `DISCARD`.
		 *
		 * @deprecated Use strength instead.
		 * @param {Number} value - The mask strength.
		 */
		setStrength(value: number): void;

	}

	/**
	 * An outline shader material.
	 *
	 * @implements {Resizable}
	 */
	export class OutlineMaterial extends ShaderMaterial implements Resizable {

		/**
		 * Constructs a new outline material.
		 *
		 * TODO Remove texelSize param.
		 * @param {Vector2} [texelSize] - The screen texel size.
		 */
		constructor(texelSize?: Vector2);
		/**
		 * The input buffer.
		 *
		 * @param {Texture} arg - The input buffer.
		 */
		set inputBuffer(arg: Texture);
		/**
		 * Sets the input buffer.
		 *
		 * @deprecated Use inputBuffer instead.
		 * @param {Texture} value - The input buffer.
		 */
		setInputBuffer(value: Texture): void;
		/**
		 * Sets the texel size.
		 *
		 * @deprecated Use setSize() instead.
		 * @param {Number} x - The texel width.
		 * @param {Number} y - The texel height.
		 */
		setTexelSize(x: number, y: number): void;
		/**
		 * Sets the size of this object.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	/**
	 * An outline shader material.
	 */
	export type OutlineEdgesMaterial = OutlineMaterial;

	/**
	 * Subpixel Morphological Antialiasing.
	 *
	 * This material computes weights for detected edges.
	 *
	 * @implements {Resizable}
	 */
	export class SMAAWeightsMaterial extends ShaderMaterial implements Resizable {

		/**
		 * Constructs a new SMAA weights material.
		 *
		 * @param {Vector2} [texelSize] - The absolute screen texel size.
		 * @param {Vector2} [resolution] - The resolution.
		 */
		constructor(texelSize?: Vector2, resolution?: Vector2);
		/**
		 * The input buffer.
		 *
		 * @param {Texture} arg - The input buffer.
		 */
		set inputBuffer(arg: Texture);
		/**
		 * Sets the input buffer.
		 *
		 * @deprecated Use inputBuffer instead.
		 * @param {Texture} value - The input buffer.
		 */
		setInputBuffer(value: Texture): void;
		set searchTexture(arg: Texture);
		/**
		 * The search lookup texture.
		 *
		 * @type {Texture}
		 */
		get searchTexture(): Texture;
		set areaTexture(arg: Texture);
		/**
		 * The area lookup texture.
		 *
		 * @type {Texture}
		 */
		get areaTexture(): Texture;
		/**
		 * Sets the search and area lookup textures.
		 *
		 * @deprecated Use searchTexture and areaTexture instead.
		 * @param {Texture} search - The search lookup texture.
		 * @param {Texture} area - The area lookup texture.
		 */
		setLookupTextures(search: Texture, area: Texture): void;
		set orthogonalSearchSteps(arg: number);
		/**
		 * The maximum amount of steps performed in the horizontal/vertical pattern searches, at each side of the pixel.
		 * Range: [0, 112].
		 *
		 * In number of pixels, it's actually the double. So the maximum line length perfectly handled by, for example 16, is
		 * 64 (perfectly means that longer lines won't look as good, but are still antialiased).
		 *
		 * @type {Number}
		 */
		get orthogonalSearchSteps(): number;
		/**
		 * Sets the maximum amount of steps performed in the horizontal/vertical pattern searches, at each side of the pixel.
		 *
		 * @deprecated Use orthogonalSearchSteps instead.
		 * @param {Number} value - The search steps. Range: [0, 112].
		 */
		setOrthogonalSearchSteps(value: number): void;
		set diagonalSearchSteps(arg: number);
		/**
		 * The maximum steps performed in the diagonal pattern searches, at each side of the pixel. This search
		 * jumps one pixel at a time. Range: [0, 20].
		 *
		 * On high-end machines this search is cheap (between 0.8x and 0.9x slower for 16 steps), but it can have a
		 * significant impact on older machines.
		 *
		 * @type {Number}
		 */
		get diagonalSearchSteps(): number;
		/**
		 * Specifies the maximum steps performed in the diagonal pattern searches, at each side of the pixel.
		 *
		 * @deprecated Use diagonalSearchSteps instead.
		 * @param {Number} value - The search steps. Range: [0, 20].
		 */
		setDiagonalSearchSteps(value: number): void;
		set diagonalDetection(arg: boolean);
		/**
		 * Indicates whether diagonal pattern detection is enabled.
		 *
		 * @type {Boolean}
		 */
		get diagonalDetection(): boolean;
		/**
		 * Indicates whether diagonal pattern detection is enabled.
		 *
		 * @deprecated Use diagonalDetection instead.
		 * @return {Boolean} Whether diagonal pattern detection is enabled.
		 */
		isDiagonalDetectionEnabled(): boolean;
		/**
		 * Enables or disables diagonal pattern detection.
		 *
		 * @deprecated Use diagonalDetection instead.
		 * @param {Boolean} value - Whether diagonal pattern detection should be enabled.
		 */
		setDiagonalDetectionEnabled(value: boolean): void;
		set cornerRounding(arg: number);
		/**
		 * Specifies how much sharp corners will be rounded. Range: [0, 100].
		 *
		 * @type {Number}
		 */
		get cornerRounding(): number;
		/**
		 * Specifies how much sharp corners will be rounded.
		 *
		 * @deprecated Use cornerRounding instead.
		 * @param {Number} value - The corner rounding amount. Range: [0, 100].
		 */
		setCornerRounding(value: number): void;
		set cornerDetection(arg: number);
		/**
		 * Indicates whether corner detection is enabled.
		 *
		 * @type {Number}
		 */
		get cornerDetection(): number;
		/**
		 * Indicates whether corner rounding is enabled.
		 *
		 * @deprecated Use cornerDetection instead.
		 * @return {Boolean} Whether corner rounding is enabled.
		 */
		isCornerRoundingEnabled(): boolean;
		/**
		 * Enables or disables corner rounding.
		 *
		 * @deprecated Use cornerDetection instead.
		 * @param {Boolean} value - Whether corner rounding should be enabled.
		 */
		setCornerRoundingEnabled(value: boolean): void;
		/**
		 * Sets the size of this object.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	/**
	 * A Screen Space Ambient Occlusion (SSAO) shader material.
	 *
	 * @implements {Resizable}
	 */
	export class SSAOMaterial extends ShaderMaterial implements Resizable {

		/**
		 * Constructs a new SSAO material.
		 *
		 * @param {Camera} camera - A camera.
		 */
		constructor(camera: Camera);
		/**
		 * The combined normal-depth buffer.
		 *
		 * @param {Texture} arg - The buffer.
		 */
		set normalDepthBuffer(arg: Texture);
		/**
		 * Sets the combined normal-depth buffer.
		 *
		 * @deprecated Use normalDepthBuffer instead.
		 * @param {Texture} value - The buffer.
		 */
		setNormalDepthBuffer(value: Texture): void;
		/**
		 * The normal buffer.
		 *
		 * @param {Texture} arg - The buffer.
		 */
		set normalBuffer(arg: Texture);
		/**
		 * Sets the normal buffer.
		 *
		 * @deprecated Use normalBuffer instead.
		 * @param {Texture} value - The buffer.
		 */
		setNormalBuffer(value: Texture): void;
		/**
		 * The depth buffer.
		 *
		 * @param {Texture} arg - The buffer.
		 */
		set depthBuffer(arg: Texture);
		/**
		 * The depth packing strategy.
		 *
		 * @param {DepthPackingStrategies} arg - The depth packing strategy.
		 */
		set depthPacking(arg: DepthPackingStrategies);
		/**
		 * Sets the depth buffer.
		 *
		 * @deprecated Use depthBuffer and depthPacking instead.
		 * @param {Texture} buffer - The depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing strategy.
		 */
		setDepthBuffer(
			buffer: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * The noise texture.
		 *
		 * @param {Texture} arg - The texture.
		 */
		set noiseTexture(arg: Texture);
		/**
		 * Sets the noise texture.
		 *
		 * @deprecated Use noiseTexture instead.
		 * @param {Texture} value - The texture.
		 */
		setNoiseTexture(value: Texture): void;
		set samples(arg: number);
		/**
		 * The sample count.
		 *
		 * @type {Number}
		 */
		get samples(): number;
		/**
		 * Returns the amount of occlusion samples per pixel.
		 *
		 * @deprecated Use samples instead.
		 * @return {Number} The sample count.
		 */
		getSamples(): number;
		/**
		 * Sets the amount of occlusion samples per pixel.
		 *
		 * @deprecated Use samples instead.
		 * @param {Number} value - The sample count.
		 */
		setSamples(value: number): void;
		set rings(arg: number);
		/**
		 * The sampling spiral ring count.
		 *
		 * @type {Number}
		 */
		get rings(): number;
		/**
		 * Returns the amount of spiral turns in the occlusion sampling pattern.
		 *
		 * @deprecated Use rings instead.
		 * @return {Number} The radius.
		 */
		getRings(): number;
		/**
		 * Sets the amount of spiral turns in the occlusion sampling pattern.
		 *
		 * @deprecated Use rings instead.
		 * @param {Number} value - The radius.
		 */
		setRings(value: number): void;
		/**
		 * The intensity.
		 *
		 * @type {Number}
		 * @deprecated Use SSAOEffect.intensity instead.
		 */
		get intensity(): number;
		set intensity(arg: number);
		/**
		 * Returns the intensity.
		 *
		 * @deprecated Use intensity instead.
		 * @return {Number} The intensity.
		 */
		getIntensity(): number;
		/**
		 * Sets the intensity.
		 *
		 * @deprecated Use intensity instead.
		 * @param {Number} value - The intensity.
		 */
		setIntensity(value: number): void;
		set fade(arg: number);
		/**
		 * The depth fade factor.
		 *
		 * @type {Number}
		 */
		get fade(): number;
		/**
		 * Returns the depth fade factor.
		 *
		 * @deprecated Use fade instead.
		 * @return {Number} The fade factor.
		 */
		getFade(): number;
		/**
		 * Sets the depth fade factor.
		 *
		 * @deprecated Use fade instead.
		 * @param {Number} value - The fade factor.
		 */
		setFade(value: number): void;
		set bias(arg: number);
		/**
		 * The depth bias. Range: [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get bias(): number;
		/**
		 * Returns the depth bias.
		 *
		 * @deprecated Use bias instead.
		 * @return {Number} The bias.
		 */
		getBias(): number;
		/**
		 * Sets the depth bias.
		 *
		 * @deprecated Use bias instead.
		 * @param {Number} value - The bias.
		 */
		setBias(value: number): void;
		set minRadiusScale(arg: number);
		/**
		 * The minimum radius scale for distance scaling. Range: [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get minRadiusScale(): number;
		/**
		 * Returns the minimum radius scale for distance scaling.
		 *
		 * @deprecated Use minRadiusScale instead.
		 * @return {Number} The minimum radius scale.
		 */
		getMinRadiusScale(): number;
		/**
		 * Sets the minimum radius scale for distance scaling.
		 *
		 * @deprecated Use minRadiusScale instead.
		 * @param {Number} value - The minimum radius scale.
		 */
		setMinRadiusScale(value: number): void;
		set radius(arg: number);
		/**
		 * The occlusion sampling radius. Range: [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get radius(): number;
		/**
		 * Returns the occlusion sampling radius.
		 *
		 * @deprecated Use radius instead.
		 * @return {Number} The radius.
		 */
		getRadius(): number;
		/**
		 * Sets the occlusion sampling radius.
		 *
		 * @deprecated Use radius instead.
		 * @param {Number} value - The radius. Range [1e-6, 1.0].
		 */
		setRadius(value: number): void;
		set distanceScaling(arg: boolean);
		/**
		 * Indicates whether distance-based radius scaling is enabled.
		 *
		 * @type {Boolean}
		 */
		get distanceScaling(): boolean;
		/**
		 * Indicates whether distance-based radius scaling is enabled.
		 *
		 * @deprecated Use distanceScaling instead.
		 * @return {Boolean} Whether distance scaling is enabled.
		 */
		isDistanceScalingEnabled(): boolean;
		/**
		 * Enables or disables distance-based radius scaling.
		 *
		 * @deprecated Use distanceScaling instead.
		 * @param {Boolean} value - Whether distance scaling should be enabled.
		 */
		setDistanceScalingEnabled(value: boolean): void;
		set distanceThreshold(arg: number);
		/**
		 * The occlusion distance threshold. Range: [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get distanceThreshold(): number;

		/**
		 * The occlusion distance falloff.
		 * The occlusion distance threshold in world units.
		 *
		 * @type {Number}
		 */

		get worldDistanceThreshold(): number;
		set worldDistanceThreshold(value: number);

		set distanceFalloff(arg: number);
		/**
		 * The occlusion distance falloff. Range: [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get distanceFalloff(): number;

		/**
		 * The occlusion distance falloff in world units.
		 *
		 * @type {Number}
		 */

		get worldDistanceFalloff(): number;
		set worldDistanceFalloff(value: number);

		/**
		 * Sets the occlusion distance cutoff.
		 *
		 * @deprecated Use distanceThreshold and distanceFalloff instead.
		 * @param {Number} threshold - The distance threshold. Range [0.0, 1.0].
		 * @param {Number} falloff - The falloff. Range [0.0, 1.0].
		 */
		setDistanceCutoff(threshold: number, falloff: number): void;
		set proximityThreshold(arg: number);
		/**
		 * The occlusion proximity threshold. Range: [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get proximityThreshold(): number;
		/**
		 * The occlusion proximity threshold in world units.
		 *
		 * @type {Number}
		 */
		get worldProximityThreshold(): number;
		set worldProximityThreshold(value: number);

		set proximityFalloff(arg: number);
		/**
		 * The occlusion proximity falloff. Range: [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get proximityFalloff(): number;

		/**
		 * The occlusion proximity falloff in world units.
		 *
		 * @type {Number}
		 */

		get worldProximityFalloff(): number;
		set worldProximityFalloff(value: number);

		/**
		 * Sets the occlusion proximity cutoff.
		 *
		 * @deprecated Use proximityThreshold and proximityFalloff instead.
		 * @param {Number} threshold - The range threshold. Range [0.0, 1.0].
		 * @param {Number} falloff - The falloff. Range [0.0, 1.0].
		 */
		setProximityCutoff(threshold: number, falloff: number): void;
		/**
		 * Sets the texel size.
		 *
		 * @deprecated Use setSize() instead.
		 * @param {Number} x - The texel width.
		 * @param {Number} y - The texel height.
		 */
		setTexelSize(x: number, y: number): void;
		/**
		 * Adopts the settings of the given camera.
		 *
		 * @param {Camera} camera - A camera.
		 */
		adoptCameraSettings(camera: Camera): void;
		/**
		 * Sets the size of this object.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	/**
	 * A resolution.
	 */
	export class Resolution extends EventDispatcher<BaseEventMap> {

		/**
		 * An auto sizing constant.
		 *
		 * Can be used to automatically calculate the width or height based on the original aspect ratio.
		 *
		 * @type {Number}
		 */
		static get AUTO_SIZE(): number;
		/**
		 * Constructs a new resolution.
		 *
		 * TODO Remove resizable param.
		 * @param {Resizable} resizable - A resizable object.
		 * @param {Number} [width=Resolution.AUTO_SIZE] - The preferred width.
		 * @param {Number} [height=Resolution.AUTO_SIZE] - The preferred height.
		 * @param {Number} [scale=1.0] - A resolution scale.
		 */
		constructor(
			resizable: Resizable,
			width?: number,
			height?: number,
			scale?: number
		);

		/**
		 * A resizable object.
		 *
		 * @type {Resizable}
		 * @deprecated Use an event listener for "change" events instead.
		 */
		resizable: Resizable;
		/**
		 * The preferred resolution.
		 *
		 * @type {Vector2}
		 * @deprecated Added for backward-compatibility.
		 */
		target: Vector2;
		set width(arg: number);
		/**
		 * The effective width.
		 *
		 * If the preferred width and height are set to {@link Resizer.AUTO_SIZE}, the base width will be returned.
		 *
		 * @type {Number}
		 */
		get width(): number;
		set preferredWidth(arg: number);
		/**
		 * The preferred width.
		 *
		 * @type {Number}
		 */
		get preferredWidth(): number;
		set height(arg: number);
		/**
		 * The effective height.
		 *
		 * If the preferred width and height are set to {@link Resizer.AUTO_SIZE}, the base height will be returned.
		 *
		 * @type {Number}
		 */
		get height(): number;
		set preferredHeight(arg: number);
		/**
		 * The preferred height.
		 *
		 * @type {Number}
		 */
		get preferredHeight(): number;
		/**
		 * Returns the effective width.
		 *
		 * If the preferred width and height are set to {@link Resizer.AUTO_SIZE}, the base width will be returned.
		 *
		 * @deprecated Use width instead.
		 * @return {Number} The effective width.
		 */
		getWidth(): number;
		/**
		 * Returns the effective height.
		 *
		 * If the preferred width and height are set to {@link Resizer.AUTO_SIZE}, the base height will be returned.
		 *
		 * @deprecated Use height instead.
		 * @return {Number} The effective height.
		 */
		getHeight(): number;
		set scale(arg: number);
		/**
		 * The resolution scale.
		 *
		 * @type {Number}
		 */
		get scale(): number;
		/**
		 * Returns the current resolution scale.
		 *
		 * @deprecated Use scale instead.
		 * @return {Number} The scale.
		 */
		getScale(): number;
		/**
		 * Sets the resolution scale.
		 *
		 * Also sets the preferred resolution to {@link Resizer.AUTO_SIZE}.
		 *
		 * @deprecated Use scale instead.
		 * @param {Number} value - The scale.
		 */
		setScale(value: number): void;
		set baseWidth(arg: number);
		/**
		 * The base width.
		 *
		 * @type {Number}
		 */
		get baseWidth(): number;
		/**
		 * Returns the base width.
		 *
		 * @deprecated Use baseWidth instead.
		 * @return {Number} The base width.
		 */
		getBaseWidth(): number;
		/**
		 * Sets the base width.
		 *
		 * @deprecated Use baseWidth instead.
		 * @param {Number} value - The width.
		 */
		setBaseWidth(value: number): void;
		set baseHeight(arg: number);
		/**
		 * The base height.
		 *
		 * @type {Number}
		 */
		get baseHeight(): number;
		/**
		 * Returns the base height.
		 *
		 * @deprecated Use baseHeight instead.
		 * @return {Number} The base height.
		 */
		getBaseHeight(): number;
		/**
		 * Sets the base height.
		 *
		 * @deprecated Use baseHeight instead.
		 * @param {Number} value - The height.
		 */
		setBaseHeight(value: number): void;
		/**
		 * Sets the base size.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setBaseSize(width: number, height: number): void;
		/**
		 * Returns the preferred width.
		 *
		 * @deprecated Use preferredWidth instead.
		 * @return {Number} The preferred width.
		 */
		getPreferredWidth(): number;
		/**
		 * Sets the preferred width.
		 *
		 * Use {@link Resizer.AUTO_SIZE} to automatically calculate the width based on the height and aspect ratio.
		 *
		 * @deprecated Use preferredWidth instead.
		 * @param {Number} value - The width.
		 */
		setPreferredWidth(value: number): void;
		/**
		 * Returns the preferred height.
		 *
		 * @deprecated Use preferredHeight instead.
		 * @return {Number} The preferred height.
		 */
		getPreferredHeight(): number;
		/**
		 * Sets the preferred height.
		 *
		 * Use {@link Resizer.AUTO_SIZE} to automatically calculate the height based on the width and aspect ratio.
		 *
		 * @deprecated Use preferredHeight instead.
		 * @param {Number} value - The height.
		 */
		setPreferredHeight(value: number): void;
		/**
		 * Sets the preferred size.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setPreferredSize(width: number, height: number): void;
		/**
		 * Copies the given resolution.
		 *
		 * @param {Resolution} resolution - The resolution.
		 */
		copy(resolution: Resolution): void;

	}

	export type Resizer = Resolution;

	/**
	 * An abstract pass.
	 *
	 * Fullscreen passes use a shared fullscreen triangle:
	 * https://michaldrobot.com/2014/04/01/gcn-execution-patterns-in-full-screen-passes/
	 *
	 * @implements {Initializable}
	 * @implements {Resizable}
	 * @implements {Disposable}
	 */
	export class Pass implements Initializable, Resizable, Disposable {

		/**
		 * Constructs a new pass.
		 *
		 * @param {String} [name] - The name of this pass. Does not have to be unique.
		 * @param {Scene} [scene] - The scene to render. The default scene contains a single mesh that fills the screen.
		 * @param {Camera} [camera] - A camera. Fullscreen effect passes don't require a camera.
		 */
		constructor(name?: string, scene?: Scene, camera?: Camera);
		/**
		 * The name of this pass.
		 *
		 * @type {String}
		 */
		name: string;
		/**
		 * The renderer.
		 *
		 * @deprecated
		 * @type {WebGLRenderer}
		 * @protected
		 */
		protected renderer: WebGLRenderer;
		/**
		 * The scene to render.
		 *
		 * @type {Scene}
		 * @protected
		 */
		protected scene: Scene;
		/**
		 * The camera.
		 *
		 * @type {Camera}
		 * @protected
		 */
		protected camera: Camera;
		/**
		 * Only relevant for subclassing.
		 *
		 * Indicates whether the {@link EffectComposer} should swap the frame buffers after this pass has finished
		 * rendering. Set this to `false` if this pass doesn't render to the output buffer or the screen. Otherwise, the
		 * contents of the input buffer will be lost.
		 *
		 * @type {Boolean}
		 */
		needsSwap: boolean;
		/**
		 * Only relevant for subclassing.
		 *
		 * Indicates whether the {@link EffectComposer} should prepare a depth texture for this pass.
		 * Set this to `true` if this pass relies on depth information from a preceding {@link RenderPass}.
		 *
		 * @type {Boolean}
		 */
		needsDepthTexture: boolean;
		/**
		 * Indicates whether this pass is enabled.
		 *
		 * @type {Boolean}
		 */
		enabled: boolean;
		/**
		 * Sets the render to screen flag.
		 *
		 * If this flag is changed, the fullscreen material will be updated as well.
		 *
		 * @type {Boolean}
		 */
		set renderToScreen(arg: boolean);
		/**
		 * Indicates whether this pass should render to screen.
		 *
		 * @type {Boolean}
		 */
		get renderToScreen(): boolean;
		/**
		 * Sets the main scene.
		 *
		 * @type {Scene}
		 */
		set mainScene(arg: Scene);
		/**
		 * Sets the main camera.
		 *
		 * @type {Camera}
		 */
		set mainCamera(arg: Camera);
		/**
		 * Sets the renderer
		 *
		 * @deprecated
		 * @param {WebGLRenderer} renderer - The renderer.
		 */
		setRenderer(renderer: WebGLRenderer): void;
		/**
		 * Indicates whether this pass is enabled.
		 *
		 * @deprecated Use enabled instead.
		 * @return {Boolean} Whether this pass is enabled.
		 */
		isEnabled(): boolean;
		/**
		 * Enables or disables this pass.
		 *
		 * @deprecated Use enabled instead.
		 * @param {Boolean} value - Whether the pass should be enabled.
		 */
		setEnabled(value: boolean): void;
		set fullscreenMaterial(arg: Material);
		/**
		 * The fullscreen material.
		 *
		 * @type {Material}
		 */
		get fullscreenMaterial(): Material;
		/**
		 * Returns the current fullscreen material.
		 *
		 * @deprecated Use fullscreenMaterial instead.
		 * @return {Material} The current fullscreen material, or null if there is none.
		 */
		getFullscreenMaterial(): Material;
		/**
		 * Sets the fullscreen material.
		 *
		 * @deprecated Use fullscreenMaterial instead.
		 * @protected
		 * @param {Material} value - A fullscreen material.
		 */
		protected setFullscreenMaterial(value: Material): void;
		/**
		 * Returns the current depth texture.
		 *
		 * @return {Texture} The current depth texture, or null if there is none.
		 */
		getDepthTexture(): Texture;
		/**
		 * Sets the depth texture.
		 *
		 * This method will be called automatically by the {@link EffectComposer}.
		 * You may override this method if your pass relies on the depth information of a preceding {@link RenderPass}.
		 *
		 * @param {Texture} depthTexture - A depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing.
		 */
		setDepthTexture(
			depthTexture: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * Renders this pass.
		 *
		 * This is an abstract method that must be overridden.
		 *
		 * @abstract
		 * @throws {Error} An error is thrown if the method is not overridden.
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

		/**
		 * Sets the size.
		 *
		 * You may override this method if you want to be informed about the size of the backbuffer/canvas.
		 * This method is called before {@link initialize} and every time the size of the {@link EffectComposer} changes.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * Performs initialization tasks.
		 *
		 * This method is called when this pass is added to an {@link EffectComposer}.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

		/**
		 * Performs a shallow search for disposable properties and deletes them.
		 *
		 * The {@link EffectComposer} calls this method when it is being destroyed. You can use it independently to free
		 * memory when you're certain that you don't need this pass anymore.
		 */
		dispose(): void;

	}

	/**
	 * A pass that renders an adaptive luminance map.
	 */
	export class AdaptiveLuminancePass extends Pass {

		/**
		 * Constructs a new adaptive luminance pass.
		 *
		 * @param {Texture} luminanceBuffer - A buffer that contains the current scene luminance.
		 * @param {Object} [options] - The options.
		 * @param {Number} [options.minLuminance=0.01] - The minimum luminance.
		 * @param {Number} [options.adaptationRate=1.0] - The luminance adaptation rate.
		 */
		constructor(
			luminanceBuffer: Texture,
			{
				minLuminance,
				adaptationRate
			}?: {
				minLuminance?: number;
				adaptationRate?: number;
			}
		);

		/**
		 * The adaptive luminance texture.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * Returns the adaptive 1x1 luminance texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * Sets the 1x1 mipmap level.
		 *
		 * This level is used to identify the smallest mipmap of the main luminance texture which contains the downsampled
		 * average scene luminance.
		 *
		 * @type {Number}
		 * @deprecated Use fullscreenMaterial.mipLevel1x1 instead.
		 */
		set mipLevel1x1(arg: number);
		/**
		 * @type {Number}
		 * @deprecated Use fullscreenMaterial.adaptationRate instead.
		 */
		set adaptationRate(arg: number);
		/**
		 * The luminance adaptation rate.
		 *
		 * @type {Number}
		 * @deprecated Use fullscreenMaterial.adaptationRate instead.
		 */
		get adaptationRate(): number;
		/**
		 * Renders the scene normals.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A Kawase blur pass.
	 */
	export class KawaseBlurPass extends Pass {

		/**
		 * An auto sizing flag.
		 *
		 * @type {Number}
		 * @deprecated Use {@link Resolution.AUTO_SIZE} instead.
		 */
		static get AUTO_SIZE(): number;
		/**
		 * Constructs a new Kawase blur pass.
		 *
		 * @param {Object} [options] - The options.
		 * @param {Number} [options.resolutionScale=0.5] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - Deprecated. Use resolutionX instead.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - Deprecated. Use resolutionY instead.
		 * @param {KernelSize} [options.kernelSize=KernelSize.MEDIUM] - The blur kernel size.
		 */
		constructor({
			resolutionScale,
			resolutionX,
			resolutionY,
			width,
			height,
			kernelSize
		}?: {
			resolutionScale?: number;
			resolutionX?: number;
			resolutionY?: number;
			width?: number;
			height?: number;
			kernelSize?: KernelSize;
		});

		resolution: Resolution;
		/**
		 * The blur material.
		 *
		 * @type {KawaseBlurMaterial}
		 */
		blurMaterial: KawaseBlurMaterial;
		/**
		 * Indicates whether dithering is enabled.
		 *
		 * @type {Boolean}
		 * @deprecated
		 */
		dithering: boolean;
		/**
		 * The kernel size.
		 *
		 * @type {KernelSize}
		 */
		kernelSize: KernelSize;
		/**
		 * Returns the resolution settings.
		 *
		 * @deprecated Use resolution instead.
		 * @return {Resolution} The resolution.
		 */
		getResolution(): Resolution;
		/**
		 * Sets the render width.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.preferredWidth instead.
		 */
		set width(arg: number);
		/**
		 * The current width of the internal render targets.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.width instead.
		 */
		get width(): number;
		/**
		 * Sets the render height.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.preferredHeight instead.
		 */
		set height(arg: number);
		/**
		 * The current height of the internal render targets.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.height instead.
		 */
		get height(): number;
		set scale(arg: number);
		/**
		 * The current blur scale.
		 *
		 * @type {Number}
		 * @deprecated Use blurMaterial.scale instead.
		 */
		get scale(): number;
		/**
		 * Returns the current blur scale.
		 *
		 * @deprecated Use blurMaterial.scale instead.
		 * @return {Number} The scale.
		 */
		getScale(): number;
		/**
		 * Sets the blur scale.
		 *
		 * This value influences the overall blur strength and should not be greater than 1. For larger blurs please increase
		 * the kernel size via {@link setKernelSize}!
		 *
		 * Note that the blur strength is closely tied to the resolution. For a smooth transition from no blur to full blur,
		 * set the width or the height to a high enough value.
		 *
		 * @deprecated Use blurMaterial.scale instead.
		 * @param {Number} value - The scale.
		 */
		setScale(value: number): void;
		/**
		 * Returns the kernel size.
		 *
		 * @deprecated Use kernelSize instead.
		 * @return {KernelSize} The kernel size.
		 */
		getKernelSize(): KernelSize;
		/**
		 * Sets the kernel size.
		 *
		 * Larger kernels require more processing power but scale well with larger render resolutions.
		 *
		 * @deprecated Use kernelSize instead.
		 * @param {KernelSize} value - The kernel size.
		 */
		setKernelSize(value: KernelSize): void;
		/**
		 * Returns the current resolution scale.
		 *
		 * @return {Number} The resolution scale.
		 * @deprecated Use resolution instead.
		 */
		getResolutionScale(): number;
		/**
		 * Sets the resolution scale.
		 *
		 * @param {Number} scale - The new resolution scale.
		 * @deprecated Use resolution instead.
		 */
		setResolutionScale(scale: number): void;
		/**
		 * Blurs the input buffer and writes the result to the output buffer. The input buffer remains intact, unless it's
		 * also used as the output buffer.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	export type BlurPass = KawaseBlurPass;

	/**
	 * A blur pass that produces a wide blur by downsampling and upsampling the input over multiple MIP levels.
	 *
	 * Based on an article by Fabrice Piquet:
	 * https://www.froyok.fr/blog/2021-12-ue4-custom-bloom/
	 */
	export class MipmapBlurPass extends Pass {

		/**
		 * A texture that contains the blurred result.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * The MIP levels. Default is 8.
		 *
		 * @type {Number}
		 */
		get levels(): number;
		set levels(value: number);
		/**
		 * The blur radius. Default is 0.85.
		 *
		 * @type {Number}
		 */
		get radius(): number;
		set radius(value: number);

	}

	/**
	 * A pass that disables the stencil test.
	 */
	export class ClearMaskPass extends Pass {

		/**
		 * Constructs a new clear mask pass.
		 */
		constructor();

		/**
		 * Disables the global stencil test.
		 * @param renderer - The renderer.
		 * @param inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A pass that clears the input buffer or the screen.
	 */
	export class ClearPass extends Pass {

		/**
		 * Constructs a new clear pass.
		 *
		 * @param {Boolean} [color=true] - Determines whether the color buffer should be cleared.
		 * @param {Boolean} [depth=true] - Determines whether the depth buffer should be cleared.
		 * @param {Boolean} [stencil=false] - Determines whether the stencil buffer should be cleared.
		 */
		constructor(color?: boolean, depth?: boolean, stencil?: boolean);
		/**
		 * Indicates whether the color buffer should be cleared.
		 *
		 * @type {Boolean}
		 * @deprecated Use setClearFlags() instead.
		 */
		color: boolean;
		/**
		 * Indicates whether the depth buffer should be cleared.
		 *
		 * @type {Boolean}
		 * @deprecated Use setClearFlags() instead.
		 */
		depth: boolean;
		/**
		 * Indicates whether the stencil buffer should be cleared.
		 *
		 * @type {Boolean}
		 * @deprecated Use setClearFlags() instead.
		 */
		stencil: boolean;
		/**
		 * An override clear color. Default is null.
		 *
		 * @type {Color}
		 */
		overrideClearColor: Color;
		/**
		 * An override clear alpha. Default is -1.
		 *
		 * @type {Number}
		 */
		overrideClearAlpha: number;
		/**
		 * Sets the clear flags.
		 *
		 * @param {Boolean} color - Whether the color buffer should be cleared.
		 * @param {Boolean} depth - Whether the depth buffer should be cleared.
		 * @param {Boolean} stencil - Whether the stencil buffer should be cleared.
		 */
		setClearFlags(color: boolean, depth: boolean, stencil: boolean): void;
		/**
		 * Returns the override clear color. Default is null.
		 *
		 * @deprecated Use overrideClearColor instead.
		 * @return {Color} The clear color.
		 */
		getOverrideClearColor(): Color;
		/**
		 * Sets the override clear color.
		 *
		 * @deprecated Use overrideClearColor instead.
		 * @param {Color} value - The clear color.
		 */
		setOverrideClearColor(value: Color): void;
		/**
		 * Returns the override clear alpha. Default is -1.
		 *
		 * @deprecated Use overrideClearAlpha instead.
		 * @return {Number} The clear alpha.
		 */
		getOverrideClearAlpha(): number;
		/**
		 * Sets the override clear alpha.
		 *
		 * @deprecated Use overrideClearAlpha instead.
		 * @param {Number} value - The clear alpha.
		 */
		setOverrideClearAlpha(value: number): void;
		/**
		 * Clears the input buffer or the screen.
		 * @param renderer - The renderer.
		 * @param inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A pass that copies the contents of an input buffer to another render target.
	 */
	export class CopyPass extends Pass {

		/**
		 * Constructs a new save pass.
		 *
		 * @param {WebGLRenderTarget} [renderTarget] - A render target.
		 * @param {Boolean} [autoResize=true] - Whether the render target size should be updated automatically.
		 */
		constructor(renderTarget?: WebGLRenderTarget, autoResize?: boolean);
		/**
		 * Enables or disables auto resizing of the render target.
		 *
		 * @type {Boolean}
		 */
		autoResize: boolean;
		set resize(arg: boolean);
		/**
		 * Enables or disables auto resizing of the render target.
		 *
		 * @deprecated Use autoResize instead.
		 * @type {Boolean}
		 */
		get resize(): boolean;
		/**
		 * The output texture.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * Returns the output texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * Enables or disables auto resizing of the render target.
		 *
		 * @deprecated Use autoResize instead.
		 * @param {Boolean} value - Whether the render target size should be updated automatically.
		 */
		setAutoResizeEnabled(value: boolean): void;
		/**
		 * Saves the input buffer.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	export type SavePass = CopyPass;

	/**
	 * A pass that copies depth into a render target.
	 */
	export class DepthCopyPass extends Pass {

		/**
		 * Constructs a new depth save pass.
		 *
		 * @param {Object} [options] - The options.
		 * @param {DepthPackingStrategies} [options.depthPacking=RGBADepthPacking] - The output depth packing.
		 */
		constructor({ depthPacking }?: { depthPacking?: DepthPackingStrategies });
		/**
		 * The output depth texture.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * Returns the output depth texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * The output depth packing.
		 *
		 * @type {DepthPackingStrategies}
		 */
		get depthPacking(): DepthPackingStrategies;
		/**
		 * Returns the output depth packing.
		 *
		 * @deprecated Use depthPacking instead.
		 * @return {DepthPackingStrategies} The depth packing.
		 */
		getDepthPacking(): DepthPackingStrategies;
		/**
		 * Copies depth from a depth texture.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A pass that downsamples the scene depth by picking the most representative depth in 2x2 texel neighborhoods. If a
	 * normal buffer is provided, the corresponding normals will be stored as well.
	 *
	 * This pass requires WebGL 2.
	 */
	export class DepthDownsamplingPass extends Pass {

		/**
		 * Constructs a new depth downsampling pass.
		 *
		 * @param {Object} [options] - The options.
		 * @param {Texture} [options.normalBuffer=null] - A texture that contains view space normals. See {@link NormalPass}.
		 * @param {Number} [options.resolutionScale=0.5] - The resolution scale.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - The render width.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - The render height.
		 */
		constructor({
			normalBuffer,
			resolutionScale,
			width,
			height
		}?: {
			normalBuffer?: Texture;
			resolutionScale?: number;
			width?: number;
			height?: number;
		});

		resolution: Resolution;
		/**
		 * The normal(RGB) + depth(A) texture.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * Returns the normal(RGB) + depth(A) texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * Returns the resolution settings.
		 *
		 * @deprecated Use resolution instead.
		 * @return {Resolution} The resolution.
		 */
		getResolution(): Resolution;
		/**
		 * Downsamples depth and scene normals.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A pass that renders a given scene into the input buffer or to screen.
	 *
	 * This pass uses a {@link ClearPass} to clear the target buffer.
	 */
	export class RenderPass extends Pass {

		/**
		 * Constructs a new render pass.
		 *
		 * @param {Scene} scene - The scene to render.
		 * @param {Camera} camera - The camera to use to render the scene.
		 * @param {Material} [overrideMaterial=null] - An override material.
		 */
		constructor(scene?: Scene, camera?: Camera, overrideMaterial?: Material);
		/**
		 * A clear pass.
		 *
		 * @type {ClearPass}
		 */
		clearPass: ClearPass;
		/**
		 * Indicates whether the scene background should be ignored.
		 *
		 * @type {Boolean}
		 */
		ignoreBackground: boolean;
		/**
		 * Indicates whether the shadow map auto update should be skipped.
		 *
		 * @type {Boolean}
		 */
		skipShadowMapUpdate: boolean;
		/**
		 * A selection of objects to render.
		 *
		 * @type {Selection}
		 */
		selection: Selection;
		set overrideMaterial(arg: Material);
		/**
		 * The current override material.
		 *
		 * @type {Material}
		 */
		get overrideMaterial(): Material;
		/**
		 * Returns the current override material.
		 *
		 * @deprecated Use overrideMaterial instead.
		 * @return {Material} The material.
		 */
		getOverrideMaterial(): Material;
		/**
		 * Sets the override material.
		 *
		 * @deprecated Use overrideMaterial instead.
		 * @param {Material} value - The material.
		 */
		setOverrideMaterial(value: Material): void;
		set clear(arg: boolean);
		/**
		 * Indicates whether the target buffer should be cleared before rendering.
		 *
		 * @type {Boolean}
		 * @deprecated Use clearPass.enabled instead.
		 */
		get clear(): boolean;
		/**
		 * Returns the selection. Default is `null` (no restriction).
		 *
		 * @deprecated Use selection instead.
		 * @return {Selection} The selection.
		 */
		getSelection(): Selection;
		/**
		 * Sets the selection. Set to `null` to disable.
		 *
		 * @deprecated Use selection instead.
		 * @param {Selection} value - The selection.
		 */
		setSelection(value: Selection): void;
		/**
		 * Indicates whether the scene background is disabled.
		 *
		 * @deprecated Use ignoreBackground instead.
		 * @return {Boolean} Whether the scene background is disabled.
		 */
		isBackgroundDisabled(): boolean;
		/**
		 * Enables or disables the scene background.
		 *
		 * @deprecated Use ignoreBackground instead.
		 * @param {Boolean} value - Whether the scene background should be disabled.
		 */
		setBackgroundDisabled(value: boolean): void;
		/**
		 * Indicates whether the shadow map auto update is disabled.
		 *
		 * @deprecated Use skipShadowMapUpdate instead.
		 * @return {Boolean} Whether the shadow map update is disabled.
		 */
		isShadowMapDisabled(): boolean;
		/**
		 * Enables or disables the shadow map auto update.
		 *
		 * @deprecated Use skipShadowMapUpdate instead.
		 * @param {Boolean} value - Whether the shadow map auto update should be disabled.
		 */
		setShadowMapDisabled(value: boolean): void;
		/**
		 * Returns the clear pass.
		 *
		 * @deprecated Use clearPass.enabled instead.
		 * @return {ClearPass} The clear pass.
		 */
		getClearPass(): ClearPass;
		/**
		 * Renders the scene.
		 * @param renderer - The renderer.
		 * @param inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A pass that renders depth into an RGBA buffer.
	 */
	export class DepthPass extends Pass {

		/**
		 * Constructs a new depth pass.
		 *
		 * @param {Scene} scene - The scene to render.
		 * @param {Camera} camera - The camera to use to render the scene.
		 * @param {Object} [options] - The options.
		 * @param {Number} [options.resolutionScale=1.0] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - Deprecated. Use resolutionX instead.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - Deprecated. Use resolutionY instead.
		 * @param {WebGLRenderTarget} [options.renderTarget] - A custom render target.
		 */
		constructor(
			scene?: Scene,
			camera?: Camera,
			{
				resolutionScale,
				resolutionX,
				resolutionY,
				width,
				height,
				renderTarget
			}?: {
				resolutionScale?: number;
				resolutionX?: number;
				resolutionY?: number;
				width?: number;
				height?: number;
				renderTarget?: WebGLRenderTarget;
			}
		);

		resolution: Resolution;
		/**
		 * The depth texture.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * Returns the depth texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * Returns the resolution settings.
		 *
		 * @deprecated Use resolution instead.
		 * @return {Resolution} The resolution.
		 */
		getResolution(): Resolution;
		/**
		 * Returns the current resolution scale.
		 *
		 * @return {Number} The resolution scale.
		 * @deprecated Use resolution instead.
		 */
		getResolutionScale(): number;
		/**
		 * Sets the resolution scale.
		 *
		 * @param {Number} scale - The new resolution scale.
		 * @deprecated Use resolution instead.
		 */
		setResolutionScale(scale: number): void;
		/**
		 * Renders the scene depth.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A depth picking pass.
	 */
	export class DepthPickingPass extends DepthCopyPass {

		/**
		 * Constructs a new depth picking pass.
		 *
		 * @param {Object} [options] - The options.
		 * @param {DepthPackingStrategies} [options.depthPacking=RGBADepthPacking] - The depth packing.
		 * @param {Number} [options.mode=DepthCopyMode.SINGLE] - The depth copy mode.
		 */
		constructor({
			depthPacking,
			mode
		}?: {
			depthPacking?: DepthPackingStrategies;
			mode?: number;
		});

		/**
		 * Reads depth at a specific screen position.
		 *
		 * Only one depth value can be picked per frame. Calling this method multiple times per frame will overwrite the
		 * picking coordinates. Unresolved promises will be abandoned.
		 *
		 * @example
		 * const ndc = new Vector3();
		 * const clientRect = myViewport.getBoundingClientRect();
		 * const clientX = pointerEvent.clientX - clientRect.left;
		 * const clientY = pointerEvent.clientY - clientRect.top;
		 * ndc.x = (clientX / myViewport.clientWidth) * 2.0 - 1.0;
		 * ndc.y = -(clientY / myViewport.clientHeight) * 2.0 + 1.0;
		 * const depth = await depthPickingPass.readDepth(ndc);
		 * ndc.z = depth * 2.0 - 1.0;
		 *
		 * const worldPosition = ndc.unproject(camera);
		 *
		 * @param {Vector2|Vector3} ndc - Normalized device coordinates. Only X and Y are relevant.
		 * @return {Promise<Number>} A promise that returns the depth on the next frame.
		 */
		readDepth(ndc: Vector2 | Vector3): Promise<number>;
		/**
		 * Copies depth and resolves depth picking promises.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A blend function enumeration.
	 *
	 * Important: Do not use `BlendFunction.SKIP` to disable effects. See
	 * [Enabling and Disabling Effects](https://github.com/vanruesc/postprocessing/wiki/Enabling-and-Disabling-Effects)
	 * for more information.
	 *
	 * Based on https://www.khronos.org/registry/OpenGL/extensions/NV/NV_blend_equation_advanced.txt
	 *
	 * @type {Object}
	 * @property {Number} SKIP - Deprecated. Use DST instead. Warning: This blend function does NOT fully disable the effect.
	 * @property {Number} SET - Deprecated. Use SRC instead.
	 * @property {Number} ADD - Additive blending. Fast, but may produce washed out results.
	 * @property {Number} ALPHA - Alpha blending. Blends based on the alpha value of the new color.
	 * @property {Number} AVERAGE - Calculates the avarage of the new color and the base color.
	 * @property {Number} COLOR - Converts the colors to HSL and blends based on color.
	 * @property {Number} COLOR_BURN - Color burn.
	 * @property {Number} COLOR_DODGE - Color dodge.
	 * @property {Number} DARKEN - Prioritize darker colors.
	 * @property {Number} DIFFERENCE - Color difference.
	 * @property {Number} DIVIDE - Color division.
	 * @property {Number} DST - Overwrites the new color with the base color. Ignores opacity.
	 * @property {Number} EXCLUSION - Color exclusion.
	 * @property {Number} HARD_LIGHT - Hard light.
	 * @property {Number} HARD_MIX - Hard mix.
	 * @property {Number} HUE - Converts the colors to HSL and blends based on hue.
	 * @property {Number} INVERT - Overwrites the base color with the inverted new color.
	 * @property {Number} INVERT_RGB - Multiplies the new color with the inverted base color.
	 * @property {Number} LIGHTEN - Prioritize lighter colors.
	 * @property {Number} LINEAR_BURN - Linear burn.
	 * @property {Number} LINEAR_DODGE - Same as ADD but limits the result to 1.
	 * @property {Number} LINEAR_LIGHT - Linear light.
	 * @property {Number} LUMINOSITY - Converts the colors to HSL and blends based on luminosity.
	 * @property {Number} MULTIPLY - Color multiplication.
	 * @property {Number} NEGATION - Negates the base color using the new color.
	 * @property {Number} NORMAL - Overwrites the base color with the new one.
	 * @property {Number} OVERLAY - Color overlay.
	 * @property {Number} PIN_LIGHT - Pin light.
	 * @property {Number} REFLECT - Color reflection.
	 * @property {Number} SCREEN - Screen blending. The two colors are effectively projected on a white screen simultaneously.
	 * @property {Number} SRC - Overwrites the base color with the new one. Ignores opacity.
	 * @property {Number} SATURATION - Converts the colors to HSL and blends based on saturation.
	 * @property {Number} SOFT_LIGHT - Soft light.
	 * @property {Number} SUBTRACT - Subtracts the new color from the base color.
	 * @property {Number} VIVID_LIGHT - Vivid light.
	 */
	export enum BlendFunction {
		SKIP,
		SET,
		ADD,
		ALPHA,
		AVERAGE,
		COLOR,
		COLOR_BURN,
		COLOR_DODGE,
		DARKEN,
		DIFFERENCE,
		DIVIDE,
		DST,
		EXCLUSION,
		HARD_LIGHT,
		HARD_MIX,
		HUE,
		INVERT,
		INVERT_RGB,
		LIGHTEN,
		LINEAR_BURN,
		LINEAR_DODGE,
		LINEAR_LIGHT,
		LUMINOSITY,
		MULTIPLY,
		NEGATION,
		NORMAL,
		OVERLAY,
		PIN_LIGHT,
		REFLECT,
		SATURATION,
		SCREEN,
		SOFT_LIGHT,
		SRC,
		SUBTRACT,
		VIVID_LIGHT
	}

	/**
	 * A blend mode.
	 */
	export class BlendMode extends EventDispatcher<BaseEventMap> {

		/**
		 * Constructs a new blend mode.
		 *
		 * @param {BlendFunction} blendFunction - The blend function.
		 * @param {Number} opacity - The opacity of the color that will be blended with the base color.
		 */
		constructor(blendFunction: BlendFunction, opacity?: number);
		/**
		 * A uniform that controls the opacity of this blend mode.
		 *
		 * TODO Add opacity accessors for uniform value.
		 * @type {Uniform}
		 */
		opacity: Uniform;
		/**
		 * Returns the opacity.
		 *
		 * @return {Number} The opacity.
		 */
		getOpacity(): number;
		/**
		 * Sets the opacity.
		 *
		 * @param {Number} value - The opacity.
		 */
		setOpacity(value: number): void;
		/**
		 * Returns the blend function.
		 *
		 * @deprecated Use blendFunction instead.
		 * @return {BlendFunction} The blend function.
		 */
		getBlendFunction(): BlendFunction;
		/**
		 * Sets the blend function.
		 *
		 * @deprecated Use blendFunction instead.
		 * @param {BlendFunction} value - The blend function.
		 */
		setBlendFunction(value: BlendFunction): void;
		/**
		 * Returns the blend function shader code.
		 *
		 * @return {String} The blend function shader code.
		 */
		getShaderCode(): string;
		/**
		 * The blend function.
		 *
		 * @type {BlendFunction}
		 */
		get blendFunction(): BlendFunction;
		set blendFunction(value: BlendFunction);

	}

	/**
	 * An abstract effect.
	 *
	 * Effects can be combined using the {@link EffectPass}.
	 *
	 * @implements {Initializable}
	 * @implements {Resizable}
	 * @implements {Disposable}
	 */
	export class Effect
		extends EventDispatcher<BaseEventMap>
		implements Initializable, Resizable, Disposable {

		/**
		 * Constructs a new effect.
		 *
		 * @param {String} name - The name of this effect. Doesn't have to be unique.
		 * @param {String} fragmentShader - The fragment shader. This shader is required.
		 * @param {Object} [options] - Additional options.
		 * @param {EffectAttribute} [options.attributes=EffectAttribute.NONE] - The effect attributes that determine the execution priority and resource requirements.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function of this effect.
		 * @param {Map<String, String>} [options.defines] - Custom preprocessor macro definitions. Keys are names and values are code.
		 * @param {Map<String, Uniform>} [options.uniforms] - Custom shader uniforms. Keys are names and values are uniforms.
		 * @param {Set<WebGLExtension>} [options.extensions] - WebGL extensions.
		 * @param {String} [options.vertexShader=null] - The vertex shader. Most effects don't need one.
		 */
		constructor(
			name: string,
			fragmentShader: string,
			{
				attributes,
				blendFunction,
				defines,
				uniforms,
				extensions,
				vertexShader
			}?: {
				attributes?: EffectAttribute;
				blendFunction?: BlendFunction;
				defines?: Map<string, string>;
				uniforms?: Map<string, Uniform>;
				extensions?: Set<WebGLExtension>;
				vertexShader?: string;
			}
		);

		/**
		 * The name of this effect.
		 *
		 * @type {String}
		 */
		name: string;
		/**
		 * The renderer.
		 *
		 * @type {WebGLRenderer}
		 * @protected
		 * @deprecated
		 */
		protected renderer: WebGLRenderer;
		/**
		 * Preprocessor macro definitions.
		 *
		 * Call {@link Effect.setChanged} after changing macro definitions.
		 *
		 * @type {Map<String, String>}
		 */
		readonly defines: Map<string, string>;
		/**
		 * Shader uniforms.
		 *
		 * Call {@link Effect.setChanged} after adding or removing uniforms.
		 *
		 * @type {Map<String, Uniform>}
		 */
		readonly uniforms: Map<string, Uniform>;
		/**
		 * WebGL extensions that are required by this effect.
		 *
		 * Call {@link Effect.setChanged} after adding or removing extensions.
		 *
		 * @type {Set<WebGLExtension>}
		 */
		readonly extensions: Set<WebGLExtension>;
		/**
		 * The blend mode of this effect.
		 *
		 * @type {BlendMode}
		 */
		readonly blendMode: BlendMode;
		/**
		 * The input color space.
		 *
		 * @type {ColorSpace}
		 * @experimental
		 */
		get inputColorSpace(): ColorSpace;
		/**
		 * @type {ColorSpace}
		 * @protected
		 * @experimental
		 */
		protected set inputColorSpace(arg: ColorSpace);
		/**
		 * The output color space.
		 *
		 * Should only be changed if this effect converts the input colors to a different color space.
		 *
		 * @type {ColorSpace}
		 * @experimental
		 */
		get outputColorSpace(): ColorSpace;
		/**
		 * @type {ColorSpace}
		 * @protected
		 * @experimental
		 */
		protected set outputColorSpace(arg: ColorSpace);
		/**
		 * Sets the main scene.
		 *
		 * @type {Scene}
		 */
		set mainScene(arg: Scene);
		/**
		 * Sets the main camera.
		 *
		 * @type {Camera}
		 */
		set mainCamera(arg: Camera);
		/**
		 * Returns the name of this effect.
		 *
		 * @deprecated Use name instead.
		 * @return {String} The name.
		 */
		getName(): string;
		/**
		 * Sets the renderer.
		 *
		 * @deprecated
		 * @param {WebGLRenderer} renderer - The renderer.
		 */
		setRenderer(renderer: WebGLRenderer): void;
		/**
		 * Returns the preprocessor macro definitions.
		 *
		 * @deprecated Use defines instead.
		 * @return {Map<String, String>} The extensions.
		 */
		getDefines(): Map<string, string>;
		/**
		 * Returns the uniforms of this effect.
		 *
		 * @deprecated Use uniforms instead.
		 * @return {Map<String, Uniform>} The extensions.
		 */
		getUniforms(): Map<string, Uniform>;
		/**
		 * Returns the WebGL extensions that are required by this effect.
		 *
		 * @deprecated Use extensions instead.
		 * @return {Set<WebGLExtension>} The extensions.
		 */
		getExtensions(): Set<WebGLExtension>;
		/**
		 * Returns the blend mode.
		 *
		 * The result of this effect will be blended with the result of the previous effect using this blend mode.
		 *
		 * @deprecated Use blendMode instead.
		 * @return {BlendMode} The blend mode.
		 */
		getBlendMode(): BlendMode;
		/**
		 * Returns the effect attributes.
		 *
		 * @return {EffectAttribute} The attributes.
		 */
		getAttributes(): EffectAttribute;
		/**
		 * Sets the effect attributes.
		 *
		 * Effects that have the same attributes will be executed in the order in which they were registered. Some attributes
		 * imply a higher priority.
		 *
		 * @protected
		 * @param {EffectAttribute} attributes - The attributes.
		 */
		protected setAttributes(attributes: EffectAttribute): void;
		/**
		 * Returns the fragment shader.
		 *
		 * @return {String} The fragment shader.
		 */
		getFragmentShader(): string;
		/**
		 * Sets the fragment shader.
		 *
		 * @protected
		 * @param {String} fragmentShader - The fragment shader.
		 */
		protected setFragmentShader(fragmentShader: string): void;
		/**
		 * Returns the vertex shader.
		 *
		 * @return {String} The vertex shader.
		 */
		getVertexShader(): string;
		/**
		 * Sets the vertex shader.
		 *
		 * @protected
		 * @param {String} vertexShader - The vertex shader.
		 */
		protected setVertexShader(vertexShader: string): void;
		/**
		 * Informs the associated {@link EffectPass} that this effect requires a shader recompilation.
		 *
		 * Should be called after changing macros or extensions and after adding/removing uniforms.
		 *
		 * @protected
		 */
		protected setChanged(): void;
		/**
		 * Sets the depth texture.
		 *
		 * You may override this method if your effect requires direct access to the depth texture that is bound to the
		 * associated {@link EffectPass}.
		 *
		 * @param {Texture} depthTexture - A depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing.
		 */
		setDepthTexture(
			depthTexture: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * Updates this effect by performing supporting operations.
		 *
		 * This method is called by the {@link EffectPass} right before the main fullscreen render operation, even if the
		 * blend function is set to `SKIP`.
		 *
		 * You may override this method if you need to update custom uniforms or render additional off-screen textures.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime?: number
		): void;

		/**
		 * Updates the size of this effect.
		 *
		 * You may override this method if you want to be informed about the size of the backbuffer/canvas.
		 * This method is called before {@link initialize} and every time the size of the {@link EffectComposer} changes.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * Performs initialization tasks.
		 *
		 * This method is called when the associated {@link EffectPass} is added to an {@link EffectComposer}.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 * @example if(!alpha && frameBufferType === UnsignedByteType) { this.myRenderTarget.texture.format = RGBFormat; }
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

		/**
		 * Performs a shallow search for properties that define a dispose method and deletes them.
		 *
		 * The {@link EffectComposer} calls this method when it is being destroyed.
		 */
		dispose(): void;

	}

	/**
	 * An enumeration of effect attributes.
	 *
	 * Attributes can be concatenated using the bitwise OR operator.
	 *
	 * @type {Object}
	 * @property {Number} NONE - No attributes. Most effects don't need to specify any attributes.
	 * @property {Number} DEPTH - Describes effects that require a depth texture.
	 * @property {Number} CONVOLUTION - Describes effects that fetch additional samples from the input buffer. There cannot be more than one effect with this attribute per {@link EffectPass}.
	 * @example const attributes = EffectAttribute.CONVOLUTION | EffectAttribute.DEPTH;
	 */
	export enum EffectAttribute {
		CONVOLUTION,
		DEPTH,
		NONE,
	}

	/**
	 * An enumeration of WebGL extensions.
	 *
	 * @type {Object}
	 * @property {String} DERIVATIVES - Enables derivatives by adding the functions dFdx, dFdy and fwidth.
	 * @property {String} FRAG_DEPTH - Enables gl_FragDepthEXT to set a depth value of a fragment from within the fragment shader.
	 * @property {String} DRAW_BUFFERS - Enables multiple render targets (MRT) support.
	 * @property {String} SHADER_TEXTURE_LOD - Enables explicit control of texture LOD.
	 */
	export enum WebGLExtension {
		DERIVATIVES = "derivatives",
		FRAG_DEPTH = "fragDepth",
		DRAW_BUFFERS = "drawBuffers",
		SHADER_TEXTURE_LOD = "shaderTextureLOD",
	}

	/**
	 * An effect pass.
	 *
	 * Use this pass to combine {@link Effect} instances.
	 */
	export class EffectPass extends Pass {

		/**
		 * Constructs a new effect pass.
		 *
		 * @param {Camera} camera - The main camera.
		 * @param {...Effect} effects - The effects that will be rendered by this pass.
		 */
		constructor(camera?: Camera, ...effects: Effect[]);
		/**
		 * The effects.
		 *
		 * Use `updateMaterial` or `recompile` after changing the effects and consider calling `dispose` to free resources
		 * of unused effects.
		 *
		 * @type {Effect[]}
		 * @protected
		 */
		private effects: Effect[];
		/**
		 * A time offset.
		 *
		 * Elapsed time will start at this value.
		 *
		 * @type {Number}
		 * @deprecated
		 */
		minTime: number;
		/**
		 * The maximum time.
		 *
		 * If the elapsed time exceeds this value, it will be reset.
		 *
		 * @type {Number}
		 * @deprecated
		 */
		maxTime: number;
		set encodeOutput(arg: boolean);
		/**
		 * Indicates whether this pass encodes its output when rendering to screen.
		 *
		 * @type {Boolean}
		 * @deprecated Use fullscreenMaterial.encodeOutput instead.
		 */
		get encodeOutput(): boolean;
		set dithering(arg: boolean);
		/**
		 * Indicates whether dithering is enabled.
		 *
		 * @type {Boolean}
		 */
		get dithering(): boolean;
		/**
		 * Updates the compound shader material.
		 */
		protected updateMaterial(): void;
		/**
		 * Rebuilds the shader material.
		 */
		recompile(): void;
		/**
		 * Sets the effects.
		 *
		 * @param effects - The effects.
		 */
		protected setEffects(effects: Effect[]): void;
		/**
		 * Returns the current depth texture.
		 * @returns The current depth texture, or null if there is none.
		 */
		getDepthTexture(): Texture;
		/**
		 * Sets the depth texture.
		 * @param depthTexture - A depth texture.
		 * @param [depthPacking = 0] - The depth packing.
		 */
		setDepthTexture(depthTexture: Texture, depthPacking?: number): void;
		/**
		 * Renders the effect.
		 * @param renderer - The renderer.
		 * @param inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

		/**
		 * Updates the size of this pass.
		 * @param width - The width.
		 * @param height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * Performs initialization tasks.
		 * @param renderer - The renderer.
		 * @param alpha - Whether the renderer uses the alpha channel or not.
		 * @param frameBufferType - The type of the main frame buffers.
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

		/**
		 * Deletes disposable objects.
		 * This pass will be inoperative after this method was called!
		 */
		dispose(): void;
		/**
		 * Handles events.
		 *
		 * @param {Event} event - An event.
		 */
		handleEvent(event: Event): void;

	}

	/**
	 * A pass that executes a given function.
	 */
	export class LambdaPass extends Pass {

		/**
		 * Constructs a new lambda pass.
		 *
		 * @param {Function} f - A function.
		 */
		constructor(f: Function);

	}

	/**
	 * A pass that renders luminance.
	 */
	export class LuminancePass extends Pass {

		/**
		 * Constructs a new luminance pass.
		 *
		 * @param {Object} [options] - The options. See {@link LuminanceMaterial} for additional options.
		 * @param {Number} [options.resolutionScale=1.0] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - Deprecated. Use resolutionX instead.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - Deprecated. Use resolutionY instead.
		 * @param {WebGLRenderTarget} [options.renderTarget] - A custom render target.
		 */
		constructor({
			resolutionScale,
			resolutionX,
			resolutionY,
			width,
			height,
			renderTarget
		}?: {
			resolutionScale?: number;
			resolutionX?: number;
			resolutionY?: number;
			width?: number;
			height?: number;
			renderTarget?: WebGLRenderTarget;
		});

		resolution: Resolution;
		/**
		 * The luminance texture.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * Returns the luminance texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * Returns the resolution settings.
		 *
		 * @deprecated Use resolution instead.
		 * @return {Resolution} The resolution.
		 */
		getResolution(): Resolution;
		/**
		 * Renders the luminance.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A stencil mask pass.
	 *
	 * This pass requires that the input and output buffers have a stencil buffer. You can enable the stencil buffer via the
	 * {@link EffectComposer} constructor.
	 */
	export class MaskPass extends Pass {

		/**
		 * Constructs a new mask pass.
		 *
		 * @param {Scene} scene - The scene to render.
		 * @param {Camera} camera - The camera to use.
		 */
		constructor(scene?: Scene, camera?: Camera);
		/**
		 * A clear pass.
		 *
		 * @type {ClearPass}
		 */
		clearPass: ClearPass;
		/**
		 * Inverse flag.
		 *
		 * @type {Boolean}
		 * @deprecated Use inverted instead.
		 */
		inverse: boolean;
		set inverted(arg: boolean);
		/**
		 * Indicates whether the mask should be inverted.
		 *
		 * @type {Boolean}
		 */
		get inverted(): boolean;
		set clear(arg: boolean);
		/**
		 * Indicates whether this pass should clear the stencil buffer.
		 *
		 * @type {Boolean}
		 * @deprecated Use clearPass.enabled instead.
		 */
		get clear(): boolean;
		/**
		 * Returns the internal clear pass.
		 *
		 * @deprecated Use clearPass.enabled instead.
		 * @return {ClearPass} The clear pass.
		 */
		getClearPass(): ClearPass;
		/**
		 * Indicates whether the mask is inverted.
		 *
		 * @deprecated Use inverted instead.
		 * @return {Boolean} Whether the mask is inverted.
		 */
		isInverted(): boolean;
		/**
		 * Enables or disable mask inversion.
		 *
		 * @deprecated Use inverted instead.
		 * @param {Boolean} value - Whether the mask should be inverted.
		 */
		setInverted(value: boolean): void;
		/**
		 * Renders the effect.
		 * @param renderer - The renderer.
		 * @param inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A pass that renders the normals of a given scene.
	 */
	export class NormalPass extends Pass {

		/**
		 * Constructs a new normal pass.
		 *
		 * @param {Scene} scene - The scene to render.
		 * @param {Camera} camera - The camera to use to render the scene.
		 * @param {Object} [options] - The options.
		 * @param {Number} [options.resolutionScale=1.0] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - Deprecated. Use resolutionX instead.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - Deprecated. Use resolutionY instead.
		 * @param {WebGLRenderTarget} [options.renderTarget] - A custom render target.
		 */
		constructor(
			scene?: Scene,
			camera?: Camera,
			{
				resolutionScale,
				resolutionX,
				resolutionY,
				width,
				height,
				renderTarget
			}?: {
				resolutionScale?: number;
				resolutionX?: number;
				resolutionY?: number;
				width?: number;
				height?: number;
				renderTarget?: WebGLRenderTarget;
			}
		);

		resolution: Resolution;
		/**
		 * The normal texture.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * The normal texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * Returns the resolution settings.
		 *
		 * @deprecated Use resolution instead.
		 * @return {Resolution} The resolution.
		 */
		getResolution(): Resolution;
		/**
		 * Returns the current resolution scale.
		 *
		 * @return {Number} The resolution scale.
		 * @deprecated Use resolution.preferredWidth or resolution.preferredHeight instead.
		 */
		getResolutionScale(): number;
		/**
		 * Sets the resolution scale.
		 *
		 * @param {Number} scale - The new resolution scale.
		 * @deprecated Use resolution.preferredWidth or resolution.preferredHeight instead.
		 */
		setResolutionScale(scale: number): void;
		/**
		 * Renders the scene normals.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * A shader pass.
	 *
	 * Renders any shader material as a fullscreen effect. This pass should not be used to create multiple chained effects.
	 * For a more efficient solution, please refer to the {@link EffectPass}.
	 */
	export class ShaderPass extends Pass {

		/**
		 * Constructs a new shader pass.
		 *
		 * @param {ShaderMaterial} material - A shader material.
		 * @param {String} [input="inputBuffer"] - The name of the input buffer uniform.
		 */
		constructor(material: ShaderMaterial, input?: string);
		/**
		 * Sets the name of the input buffer uniform.
		 *
		 * Most fullscreen materials modify texels from an input texture. This pass automatically assigns the main input
		 * buffer to the uniform identified by the given name.
		 *
		 * @param {String} input - The name of the input buffer uniform.
		 */
		setInput(input: string): void;
		/**
		 * Renders the effect.
		 * @param renderer - The renderer.
		 * @param inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.
		 * @param [deltaTime] - The time between the last frame and the current one in seconds.
		 * @param [stencilTest] - Indicates whether a stencil mask is active.
		 */
		render(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget | null,
			outputBuffer: WebGLRenderTarget | null,
			deltaTime?: number,
			stencilTest?: boolean
		): void;

	}

	/**
	 * The EffectComposer may be used in place of a normal WebGLRenderer.
	 *
	 * The auto clear behaviour of the provided renderer will be disabled to prevent unnecessary clear operations.
	 *
	 * It is common practice to use a {@link RenderPass} as the first pass to automatically clear the buffers and render a
	 * scene for further processing.
	 *
	 * @implements {Resizable}
	 * @implements {Disposable}
	 */
	export class EffectComposer implements Resizable, Disposable {

		/**
		 * Constructs a new effect composer.
		 *
		 * @param {WebGLRenderer} renderer - The renderer that should be used.
		 * @param {Object} [options] - The options.
		 * @param {Boolean} [options.depthBuffer=true] - Whether the main render targets should have a depth buffer.
		 * @param {Boolean} [options.stencilBuffer=false] - Whether the main render targets should have a stencil buffer.
		 * @param {Boolean} [options.alpha] - Deprecated. Buffers are always RGBA since three r137.
		 * @param {Number} [options.multisampling=0] - The number of samples used for multisample antialiasing. Requires WebGL 2.
		 * @param {Number} [options.frameBufferType] - The type of the internal frame buffers. It's recommended to use HalfFloatType if possible.
		 */
		constructor(
			renderer?: WebGLRenderer,
			{
				depthBuffer,
				stencilBuffer,
				multisampling,
				frameBufferType
			}?: {
				depthBuffer?: boolean;
				stencilBuffer?: boolean;
				alpha?: boolean;
				multisampling?: number;
				frameBufferType?: number;
			}
		);

		/**
		 * The input buffer.
		 *
		 * Two identical buffers are used to avoid reading from and writing to the same render target.
		 *
		 * @type {WebGLRenderTarget}
		 */
		inputBuffer: WebGLRenderTarget;
		/**
		 * The output buffer.
		 *
		 * @type {WebGLRenderTarget}
		 */
		outputBuffer: WebGLRenderTarget;
		/**
		 * The passes.
		 *
		 * @type {Pass[]}
		 */
		passes: Pass[];
		/**
		 * Determines whether the last pass automatically renders to screen.
		 *
		 * @type {Boolean}
		 */
		autoRenderToScreen: boolean;
		/**
		 * Sets the amount of MSAA samples.
		 *
		 * Requires WebGL 2. Set to zero to disable multisampling.
		 *
		 * @type {Number}
		 */
		set multisampling(arg: number);
		/**
		 * The current amount of samples used for multisample anti-aliasing.
		 *
		 * @type {Number}
		 */
		get multisampling(): number;
		/**
		 * Returns the internal timer.
		 *
		 * @return {Timer} The timer.
		 */
		getTimer(): Timer;
		/**
		 * Returns the renderer.
		 *
		 * @return {WebGLRenderer} The renderer.
		 */
		getRenderer(): WebGLRenderer;
		/**
		 * Sets the renderer.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 */
		setRenderer(renderer: WebGLRenderer): void;
		/**
		 * Replaces the current renderer with the given one.
		 *
		 * The auto clear mechanism of the provided renderer will be disabled. If the new render size differs from the
		 * previous one, all passes will be updated.
		 *
		 * By default, the DOM element of the current renderer will automatically be removed from its parent node and the DOM
		 * element of the new renderer will take its place.
		 *
		 * @deprecated Use setRenderer instead.
		 * @param {WebGLRenderer} renderer - The new renderer.
		 * @param {Boolean} updateDOM - Indicates whether the old canvas should be replaced by the new one in the DOM.
		 * @return {WebGLRenderer} The old renderer.
		 */
		replaceRenderer(
			renderer: WebGLRenderer,
			updateDOM?: boolean
		): WebGLRenderer;
		/**
		 * Creates a new render target.
		 *
		 * @deprecated Create buffers manually via WebGLRenderTarget instead.
		 * @param {Boolean} depthBuffer - Whether the render target should have a depth buffer.
		 * @param {Boolean} stencilBuffer - Whether the render target should have a stencil buffer.
		 * @param {Number} type - The frame buffer type.
		 * @param {Number} multisampling - The number of samples to use for antialiasing.
		 * @return {WebGLRenderTarget} A new render target that equals the renderer's canvas.
		 */
		createBuffer(
			depthBuffer: boolean,
			stencilBuffer: boolean,
			type: number,
			multisampling: number
		): WebGLRenderTarget;
		/**
		 * Can be used to change the main scene for all registered passes and effects.
		 *
		 * @param {Scene} scene - The scene.
		 */
		setMainScene(scene: Scene): void;
		/**
		 * Can be used to change the main camera for all registered passes and effects.
		 *
		 * @param {Camera} camera - The camera.
		 */
		setMainCamera(camera: Camera): void;
		/**
		 * Adds a pass, optionally at a specific index.
		 *
		 * @param {Pass} pass - A new pass.
		 * @param {Number} [index] - An index at which the pass should be inserted.
		 */
		addPass(pass: Pass, index?: number): void;
		/**
		 * Removes a pass.
		 *
		 * @param {Pass} pass - The pass.
		 */
		removePass(pass: Pass): void;
		/**
		 * Removes all passes.
		 */
		removeAllPasses(): void;
		/**
		 * Renders all enabled passes in the order in which they were added.
		 *
		 * @param {Number} [deltaTime] - The time since the last frame in seconds.
		 */
		render(deltaTime?: number): void;
		/**
		 * Sets the size of the buffers, passes and the renderer.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 * @param {Boolean} [updateStyle] - Determines whether the style of the canvas should be updated.
		 */
		setSize(width: number, height: number, updateStyle?: boolean): void;
		/**
		 * Resets this composer by deleting all passes and creating new buffers.
		 */
		reset(): void;
		/**
		 * Disposes this composer and all passes.
		 */
		dispose(): void;

	}

	/**
	 * An override material manager.
	 *
	 * Includes a workaround that fixes override materials for skinned meshes and instancing. Doesn't fix uniforms such as
	 * normal maps and displacement maps. Using the workaround may have a negative impact on performance if the scene
	 * contains a lot of meshes.
	 *
	 * @implements {Disposable}
	 */
	export class OverrideMaterialManager implements Disposable {

		/**
		 * Enables or disables the override material workaround globally.
		 *
		 * This only affects post processing passes and effects.
		 *
		 * @type {Boolean}
		 */
		static set workaroundEnabled(arg: boolean);
		/**
		 * Indicates whether the override material workaround is enabled.
		 *
		 * @type {Boolean}
		 */
		static get workaroundEnabled(): boolean;
		/**
		 * Constructs a new override material manager.
		 *
		 * @param {Material} [material=null] - An override material.
		 */
		constructor(material?: Material);
		/**
		 * Sets the override material.
		 *
		 * @param {Material} material - The material.
		 */
		setMaterial(material: Material): void;
		/**
		 * Performs cleanup tasks.
		 */
		dispose(): void;

	}

	/**
	 * The Resizable contract.
	 *
	 * Implemented by objects that can be resized.
	 *
	 * @interface
	 */
	export interface Resizable {

		/**
		 * Sets the size of this object.
		 *
		 * @param {number} width - The width.
		 * @param {number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	/**
	 * A timer that provides read access to time data.
	 *
	 * @interface
	 */
	export interface ImmutableTimer {

		/**
		* The current delta time in seconds.
		*
		* @type {Number}
		*/
		getDelta(): number;
		/**
		* The elapsed time in seconds.
		*
		* @type {Number}
		*/
		getElapsed(): number;

	}

	/**
	 * An object selection.
	 *
	 * Object selections use render layers to facilitate quick and efficient visibility changes.
	 */
	export class Selection extends Set<Object3D> {

		/**
		 * Constructs a new selection.
		 *
		 * @param {Iterable<Object3D>} [iterable] - A collection of objects that should be added to this selection.
		 * @param {Number} [layer=10] - A dedicated render layer for selected objects.
		 */
		constructor(iterable?: Iterable<Object3D>, layer?: number);
		/**
		 * Controls whether objects that are added to this selection should be removed from all other layers.
		 *
		 * @type {Boolean}
		 */
		exclusive: boolean;
		set layer(arg: number);
		/**
		 * The render layer for selected objects.
		 *
		 * @type {Number}
		 */
		get layer(): number;
		/**
		 * Returns the current render layer for selected objects.
		 *
		 * The default layer is 10. If this collides with your own custom layers, please change it before rendering!
		 *
		 * @deprecated Use layer instead.
		 * @return {Number} The layer.
		 */
		getLayer(): number;
		/**
		 * Sets the render layer for selected objects.
		 *
		 * The current selection will be updated accordingly.
		 *
		 * @deprecated Use layer instead.
		 * @param {Number} value - The layer. Range is [0, 31].
		 */
		setLayer(value: number): void;
		/**
		 * Indicates whether objects that are added to this selection will be removed from all other layers.
		 *
		 * @deprecated Use exclusive instead.
		 * @return {Number} Whether this selection is exclusive. Default is false.
		 */
		isExclusive(): number;
		/**
		 * Controls whether objects that are added to this selection should be removed from all other layers.
		 *
		 * @deprecated Use exclusive instead.
		 * @param {Number} value - Whether this selection should be exclusive.
		 */
		setExclusive(value: number): void;
		/**
		 * Clears this selection.
		 *
		 * @return {Selection} This selection.
		 */
		clear(): this;
		/**
		 * Clears this selection and adds the given objects.
		 *
		 * @param {Iterable<Object3D>} objects - The objects that should be selected.
		 * @return {Selection} This selection.
		 */
		set(objects: Iterable<Object3D>): this;
		/**
		 * An alias for {@link has}.
		 *
		 * @param {Object3D} object - An object.
		 * @return {Number} Returns 0 if the given object is currently selected, or -1 otherwise.
		 * @deprecated Added for backward-compatibility.
		 */
		indexOf(object: Object3D): number;
		/**
		 * Adds an object to this selection.
		 *
		 * If {@link exclusive} is set to `true`, the object will also be removed from all other layers.
		 *
		 * @param {Object3D} object - The object that should be selected.
		 * @return {Selection} This selection.
		 */
		add(object: Object3D): this;
		/**
		 * Removes an existing object from the selection. If the object doesn't exist it's added instead.
		 *
		 * @param {Object3D} object - The object.
		 * @return {Boolean} Returns true if the object is added, false otherwise.
		 */
		toggle(object: Object3D): boolean;
		/**
		 * Sets the visibility of all selected objects.
		 *
		 * This method enables or disables render layer 0 of all selected objects.
		 *
		 * @param {Boolean} visible - Whether the selected objects should be visible.
		 * @return {Selection} This selection.
		 */
		setVisible(visible: boolean): this;

	}

	/**
	 * A timer.
	 *
	 * Original implementation by Michael Herzog (Mugen87).
	 *
 	 * @deprecated Use `three/addons/misc/Timer.js` instead.
	 * @implements {ImmutableTimer}
	 * @implements {Disposable}
	 * @implements {EventListenerObject}
	 */
	export class Timer implements Disposable, ImmutableTimer, EventListenerObject {
		handleEvent(object: Event): void;
		/**
		 * The current delta time in seconds.
		 */
		get delta(): number;
		/**
		 * The fixed delta time in seconds.
		 */
		get fixedDelta(): number;
		set fixedDelta(value: number);
		/**
		 * The elapsed time in seconds.
		 */
		get elapsed(): number;
		/**
		 * Determines whether this timer should use a fixed time step.
		 */
		useFixedDelta: boolean;
		/**
		 * The timescale.
		 */
		timescale: number;
		/**
		 * Enables or disables auto reset based on page visibility.
		 *
		 * If enabled, the timer will be reset when the page becomes visible. This effectively pauses the timer when the page
		 * is hidden. Has no effect if the API is not supported.
		 *
		 * @see https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API
		 */
		get autoReset(): boolean;
		set autoReset(value: boolean);

		getDelta(): number;
		getElapsed(): number;
		/**
		 * Updates this timer.
		 *
		 * @param {Number} [timestamp] - The current time in milliseconds.
		 */
		update(timestamp?: number): void;
		/**
		 * Resets this timer.
		 *
		 * @return {Timer} This timer.
		 */
		reset(): Timer;
		/**
		 * Disposes this timer.
		 */
		dispose(): void;

	}

	/**
	 * An ASCII effect.
	 *
	 * Warning: This effect cannot be merged with convolution effects.
	 */
	export class ASCIIEffect extends Effect {

		/**
		 * Constructs a new ASCII effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {ASCIITexture} [options.asciiTexture] - An ASCII character lookup texture.
		 * @param {Number} [options.cellSize=16] - The cell size. It's recommended to use even numbers.
		 * @param {Number} [options.color=null] - A color to use instead of the scene colors.
		 * @param {Boolean} [options.inverted=false] - Inverts the effect.
		 */
		constructor({
			asciiTexture,
			cellSize,
			color,
			inverted
		}?: {
			asciiTexture?: ASCIITexture | null;
			cellSize?: number;
			color?: Color | string | number | null;
			inverted?: boolean;
		});

		/**
		 * The current ASCII lookup texture.
		 *
		 * @type {ASCIITexture}
		 */
		get asciiTexture(): ASCIITexture | null;
		set asciiTexture(value: ASCIITexture | null);
		/**
		 * A color that overrides the scene colors.
		 *
		 * @type {Color | string | number | null}
		 */
		get color(): Color;
		set color(value: Color | string | number | null);
		/**
		 * Controls whether the effect should be inverted.
		 *
		 * @type {Boolean}
		 */
		get inverted(): boolean;
		set inverted(value: boolean);
		/**
		 * The cell size.
		 *
		 * @type {Number}
		 */
		get cellSize(): number;
		set cellSize(value: number);

	}

	export type BloomEffectOptions = {
		blendFunction?: BlendFunction;
		luminanceThreshold?: number;
		luminanceSmoothing?: number;
		mipmapBlur?: boolean;
		intensity?: number;
		radius?: number;
		levels?: number;
		kernelSize?: KernelSize;
		resolutionScale?: number;
		width?: number;
		height?: number;
		resolutionX?: number;
		resolutionY?: number;
	};

	/**
	 * A bloom effect.
	 */
	export class BloomEffect extends Effect {

		/**
		 * Constructs a new bloom effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function of this effect.
		 * @param {Number} [options.luminanceThreshold=0.9] - The luminance threshold. Raise this value to mask out darker elements in the scene.
		 * @param {Number} [options.luminanceSmoothing=0.025] - Controls the smoothness of the luminance threshold.
		 * @param {Boolean} [options.mipmapBlur=false] - Enables or disables mipmap blur.
		 * @param {Number} [options.intensity=1.0] - The bloom intensity.
		 * @param {Number} [options.radius=0.85] - The blur radius. Only applies to mipmap blur.
		 * @param {Number} [options.levels=8] - The amount of MIP levels. Only applies to mipmap blur.
		 * @param {KernelSize} [options.kernelSize=KernelSize.LARGE] - Deprecated. Use mipmapBlur instead.
		 * @param {Number} [options.resolutionScale=0.5] - Deprecated. Use mipmapBlur instead.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - Deprecated. Use mipmapBlur instead.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - Deprecated. Use mipmapBlur instead.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - Deprecated. Use mipmapBlur instead.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - Deprecated. Use mipmapBlur instead.
		 */
		constructor({
			blendFunction,
			luminanceThreshold,
			luminanceSmoothing,
			mipmapBlur,
			intensity,
			radius,
			levels,
			kernelSize,
			resolutionScale,
			width,
			height,
			resolutionX,
			resolutionY
		}?: BloomEffectOptions);

		/**
		 * A luminance shader pass.
		 *
		 * This pass can be disabled to skip luminance filtering.
		 *
		 * @type {LuminancePass}
		 * @readonly
		 */
		readonly luminancePass: LuminancePass;
		/**
		 * A blur pass.
		 *
		 * @type {KawaseBlurPass}
		 * @readonly
		 * @deprecated Use mipmapBlurPass instead.
		 */
		readonly blurPass: KawaseBlurPass;
		/**
		 * A mipmap blur pass.
		 *
		 * @type {MipmapBlurPass}
		 * @readonly
		 */
		readonly mipmapBlurPass: MipmapBlurPass;
		/**
		 * A texture that contains the intermediate result of this effect.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * Returns the generated bloom texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * The resolution of this effect.
		 *
		 * @type {Resolution}
		 */
		get resolution(): Resolution;
		/**
		 * Returns the resolution settings.
		 *
		 * @deprecated Use resolution instead.
		 * @return {Resolution} The resolution.
		 */
		getResolution(): Resolution;
		/**
		 * Returns the blur pass.
		 *
		 * @deprecated Use blurPass instead.
		 * @return {KawaseBlurPass} The blur pass.
		 */
		getBlurPass(): KawaseBlurPass;
		/**
		 * Returns the luminance pass.
		 *
		 * @deprecated Use luminancePass instead.
		 * @return {LuminancePass} The luminance pass.
		 */
		getLuminancePass(): LuminancePass;
		/**
		 * The luminance material.
		 *
		 * @type {LuminanceMaterial}
		 */
		get luminanceMaterial(): LuminanceMaterial;
		/**
		 * Returns the luminance material.
		 *
		 * @deprecated Use luminanceMaterial instead.
		 * @return {LuminanceMaterial} The material.
		 */
		getLuminanceMaterial(): LuminanceMaterial;
		set width(arg: number);
		/**
		 * The current width of the internal render targets.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.width instead.
		 */
		get width(): number;
		set height(arg: number);
		/**
		 * The current height of the internal render targets.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.height instead.
		 */
		get height(): number;
		set dithering(arg: boolean);
		/**
		 * Indicates whether dithering is enabled.
		 *
		 * @type {Boolean}
		 * @deprecated Use EffectPass.fullscreenMaterial.dithering instead.
		 */
		get dithering(): boolean;
		set kernelSize(arg: KernelSize);
		/**
		 * The blur kernel size.
		 *
		 * @type {KernelSize}
		 * @deprecated Use blurPass.kernelSize instead.
		 */
		get kernelSize(): KernelSize;
		set distinction(arg: number);
		/**
		 * @type {Number}
		 * @deprecated Use luminanceMaterial instead.
		 */
		get distinction(): number;
		set intensity(arg: number);
		/**
		 * The bloom intensity.
		 *
		 * @type {Number}
		 */
		get intensity(): number;
		/**
		 * The bloom intensity.
		 *
		 * @deprecated Use intensity instead.
		 * @return {Number} The intensity.
		 */
		getIntensity(): number;
		/**
		 * Sets the bloom intensity.
		 *
		 * @deprecated Use intensity instead.
		 * @param {Number} value - The intensity.
		 */
		setIntensity(value: number): void;
		/**
		 * Returns the current resolution scale.
		 *
		 * @return {Number} The resolution scale.
		 * @deprecated Use resolution instead.
		 */
		getResolutionScale(): number;
		/**
		 * Sets the resolution scale.
		 *
		 * @param {Number} scale - The new resolution scale.
		 * @deprecated Use resolution instead.
		 */
		setResolutionScale(scale: number): void;
		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime?: number
		): void;

		/**
		 * Updates the size of internal render targets.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * Performs initialization tasks.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

	}

	/**
	 * A depth of field (bokeh) effect.
	 *
	 * Original shader code by Martins Upitis:
	 *	http://artmartinsh.blogspot.com/2010/02/glsl-lens-blur-filter-with-bokeh.html
	 *
	 * @deprecated Use DepthOfFieldEffect instead.
	 */
	export class BokehEffect extends Effect {

		/**
		 * Constructs a new bokeh effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Number} [options.focus=0.5] - The focus distance ratio, ranging from 0.0 to 1.0.
		 * @param {Number} [options.dof=0.02] - Depth of field. An area in front of and behind the focal point that still appears sharp.
		 * @param {Number} [options.aperture=0.015] - Camera aperture scale. Bigger values for stronger blur and shallower depth of field.
		 * @param {Number} [options.maxBlur=1.0] - The maximum blur strength.
		 */
		constructor({
			blendFunction,
			focus,
			dof,
			aperture,
			maxBlur
		}?: {
			blendFunction?: BlendFunction;
			focus?: number;
			dof?: number;
			aperture?: number;
			maxBlur?: number;
		});

	}

	/**
	 * A brightness/contrast effect.
	 *
	 * Reference: https://github.com/evanw/glfx.js
	 */
	export class BrightnessContrastEffect extends Effect {

		/**
		 * Constructs a new brightness/contrast effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Number} [options.brightness=0.0] - The brightness factor, ranging from -1 to 1, where 0 means no change.
		 * @param {Number} [options.contrast=0.0] - The contrast factor, ranging from -1 to 1, where 0 means no change.
		 */
		constructor({
			blendFunction,
			brightness,
			contrast
		}?: {
			blendFunction?: BlendFunction;
			brightness?: number;
			contrast?: number;
		});

		set brightness(arg: number);
		/**
		 * The brightness.
		 *
		 * @type {Number}
		 */
		get brightness(): number;
		/**
		 * Returns the brightness.
		 *
		 * @deprecated Use brightness instead.
		 * @return {Number} The brightness.
		 */
		getBrightness(): number;
		/**
		 * Sets the brightness.
		 *
		 * @deprecated Use brightness instead.
		 * @param {Number} value - The brightness.
		 */
		setBrightness(value: number): void;
		set contrast(arg: number);
		/**
		 * The contrast.
		 *
		 * @type {Number}
		 */
		get contrast(): number;
		/**
		 * Returns the contrast.
		 *
		 * @deprecated Use contrast instead.
		 * @return {Number} The contrast.
		 */
		getContrast(): number;
		/**
		 * Sets the contrast.
		 *
		 * @deprecated Use contrast instead.
		 * @param {Number} value - The contrast.
		 */
		setContrast(value: number): void;

	}

	/**
	 * A chromatic aberration effect.
	 */
	export class ChromaticAberrationEffect extends Effect {

		/**
		 * Constructs a new chromatic aberration effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Vector2} [options.offset] - The color offset.
		 * @param {Boolean} [options.radialModulation=false] - Whether the effect should be modulated with a radial gradient.
		 * @param {Number} [options.modulationOffset=0.15] - The modulation offset. Only applies if `radialModulation` is enabled.
		 */
		constructor({
			blendFunction,
			offset,
			radialModulation,
			modulationOffset
		}?: {
			blendFunction?: BlendFunction;
			offset?: Vector2;
			radialModulation: boolean,
			modulationOffset: number
		});

		set offset(arg: Vector2);
		/**
		 * The color offset.
		 *
		 * @type {Vector2}
		 */
		get offset(): Vector2;
		/**
		 * Indicates whether radial modulation is enabled.
		 *
		 * When enabled, the effect will be weaker in the middle and stronger towards the screen edges.
		 *
		 * @type {Boolean}
		 */
		get radialModulation(): boolean;
		set radialModulation(arg: boolean);
		/**
		 * The modulation offset.
		 *
		 * @type {Number}
		 */
		get modulationOffset(): number;
		set modulationOffset(arg: number);
		/**
		 * Returns the color offset vector.
		 *
		 * @deprecated Use offset instead.
		 * @return {Vector2} The offset.
		 */
		getOffset(): Vector2;
		/**
		 * Sets the color offset vector.
		 *
		 * @deprecated Use offset instead.
		 * @param {Vector2} value - The offset.
		 */
		setOffset(value: Vector2): void;

	}

	/**
	 * A fast greyscale effect.
	 */
	export class ColorAverageEffect extends Effect {

		/**
		 * Constructs a new color average effect.
		 *
		 * @param {BlendFunction} [blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 */
		constructor(blendFunction?: BlendFunction);

	}

	/**
	 * A color depth effect.
	 *
	 * Simulates a hardware limitation to achieve a retro feel. The real color depth will not be altered by this effect.
	 */
	export class ColorDepthEffect extends Effect {

		/**
		 * Constructs a new color depth effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Number} [options.bits=16] - The color bit depth.
		 */
		constructor({
			blendFunction,
			bits
		}?: {
			blendFunction?: BlendFunction;
			bits?: number;
		});

		set bitDepth(arg: number);
		/**
		 * The virtual amount of color bits.
		 *
		 * Each color channel effectively uses a fourth of the total amount of bits. Alpha remains unaffected.
		 *
		 * @type {Number}
		 */
		get bitDepth(): number;
		/**
		 * Returns the current color bit depth.
		 *
		 * @return {Number} The bit depth.
		 */
		getBitDepth(): number;
		/**
		 * Sets the virtual amount of color bits.
		 *
		 * @param {Number} value - The bit depth.
		 */
		setBitDepth(value: number): void;

	}

	/**
	 * A depth visualization effect.
	 *
	 * Useful for debugging.
	 */
	export class DepthEffect extends Effect {

		/**
		 * Constructs a new depth effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Boolean} [options.inverted=false] - Whether the depth should be inverted.
		 */
		constructor({
			blendFunction,
			inverted
		}?: {
			blendFunction?: BlendFunction;
			inverted?: boolean;
		});

		set inverted(arg: boolean);
		/**
		 * Indicates whether depth should be inverted.
		 *
		 * @type {Boolean}
		 */
		get inverted(): boolean;
		/**
		 * Indicates whether the rendered depth is inverted.
		 *
		 * @deprecated Use inverted instead.
		 * @return {Boolean} Whether the rendered depth is inverted.
		 */
		isInverted(): boolean;
		/**
		 * Enables or disables depth inversion.
		 *
		 * @deprecated Use inverted instead.
		 * @param {Boolean} value - Whether depth should be inverted.
		 */
		setInverted(value: boolean): void;

	}

	/**
	 * A depth of field effect.
	 *
	 * Based on a graphics study by Adrian Courrèges and an article by Steve Avery:
	 *	https://www.adriancourreges.com/blog/2016/09/09/doom-2016-graphics-study/
	 *	https://pixelmischiefblog.wordpress.com/2016/11/25/bokeh-depth-of-field/
	 */
	export class DepthOfFieldEffect extends Effect {

		/**
		 * Constructs a new depth of field effect.
		 *
		 * @param {Camera} camera - The main camera.
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Number} [options.worldFocusDistance] - The focus distance in world units.
		 * @param {Number} [options.worldFocusRange] - The focus distance in world units.
		 * @param {Number} [options.focusDistance=0.0] - The normalized focus distance. Range is [0.0, 1.0].
		 * @param {Number} [options.focalLength=0.1] - The focal length. Range is [0.0, 1.0].
		 * @param {Number} [options.focusRange=0.1] - The focus range. Range is [0.0, 1.0].
		 * @param {Number} [options.focalLength=0.1] - Deprecated.
		 * @param {Number} [options.bokehScale=1.0] - The scale of the bokeh blur.
		 * @param {Number} [options.resolutionScale=1.0] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - Deprecated. Use resolutionX instead.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - Deprecated. Use resolutionY instead.
		 */
		constructor(
			camera?: Camera,
			{
				blendFunction,
				worldFocusDistance,
				worldFocusRange,
				focusDistance,
				focalLength,
				focusRange,
				bokehScale,
				resolutionScale,
				resolutionX,
				resolutionY,
				width,
				height
			}?: {
				blendFunction?: BlendFunction;
				worldFocusDistance?: number;
				worldFocusRange?: number;
				focusDistance?: number;
				focalLength?: number;
				focusRange?: number;
				bokehScale?: number;
				resolutionScale?: number;
				resolutionX?: number;
				resolutionY?: number;
				width?: number;
				height?: number;
			}
		);

		/**
		 * This pass blurs the foreground CoC buffer to soften edges.
		 *
		 * @type {KawaseBlurPass}
		 */
		readonly blurPass: KawaseBlurPass;
		/**
		 * A target position that should be kept in focus. Set to `null` to disable auto focus.
		 *
		 * @type {Vector3}
		 */
		target: Vector3;
		set bokehScale(arg: number);
		/**
		 * The current bokeh scale.
		 *
		 * @type {Number}
		 */
		get bokehScale(): number;
		/**
		 * The circle of confusion texture.
		 *
		 * @type {Texture}
		 */
		get cocTexture(): Texture;
		/**
		 * The mask function. Default is `MULTIPLY_RGB`.
		 *
		 * @type {MaskFunction}
		 */
		get maskFunction(): MaskFunction;
		set maskFunction(arg: MaskFunction);
		/**
		 * The circle of confusion material.
		 *
		 * @type {CircleOfConfusionMaterial}
		 */
		get cocMaterial(): CircleOfConfusionMaterial;
		/**
		 * The circle of confusion material.
		 *
		 * @deprecated Use cocMaterial instead.
		 * @type {CircleOfConfusionMaterial}
		 */
		get circleOfConfusionMaterial(): CircleOfConfusionMaterial;
		/**
		 * Returns the circle of confusion material.
		 *
		 * @deprecated Use cocMaterial instead.
		 * @return {CircleOfConfusionMaterial} The material.
		 */
		getCircleOfConfusionMaterial(): CircleOfConfusionMaterial;
		/**
		 * Returns the pass that blurs the foreground CoC buffer to soften edges.
		 *
		 * @deprecated Use blurPass instead.
		 * @return {KawaseBlurPass} The blur pass.
		 */
		getBlurPass(): KawaseBlurPass;
		/**
		 * The resolution of this effect.
		 *
		 * @type {Resolution}
		 */
		get resolution(): Resolution;
		/**
		 * Returns the resolution settings.
		 *
		 * @deprecated Use resolution instead.
		 * @return {Resolution} The resolution.
		 */
		getResolution(): Resolution;
		/**
		 * Returns the current bokeh scale.
		 *
		 * @deprecated Use bokehScale instead.
		 * @return {Number} The scale.
		 */
		getBokehScale(): number;
		/**
		 * Sets the bokeh scale.
		 *
		 * @deprecated Use bokehScale instead.
		 * @param {Number} value - The scale.
		 */
		setBokehScale(value: number): void;
		/**
		 * Returns the current auto focus target.
		 *
		 * @deprecated Use target instead.
		 * @return {Vector3} The target.
		 */
		getTarget(): Vector3;
		/**
		 * Sets the auto focus target.
		 *
		 * @deprecated Use target instead.
		 * @param {Vector3} value - The target.
		 */
		setTarget(value: Vector3): void;
		/**
		 * Calculates the focus distance from the camera to the given position.
		 *
		 * @param {Vector3} target - The target.
		 * @return {Number} The normalized focus distance.
		 */
		calculateFocusDistance(target: Vector3): number;
		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime?: number
		): void;

		/**
		 * Updates the size of internal render targets.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * Performs initialization tasks.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

	}

	/**
	 * A dot screen effect.
	 */
	export class DotScreenEffect extends Effect {

		/**
		 * Constructs a new dot screen effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Number} [options.angle=1.57] - The angle of the dot pattern.
		 * @param {Number} [options.scale=1.0] - The scale of the dot pattern.
		 */
		constructor({
			blendFunction,
			angle,
			scale
		}?: {
			blendFunction?: BlendFunction;
			angle?: number;
			scale?: number;
		});

		set angle(arg: number);
		/**
		 * The angle.
		 *
		 * @type {Number}
		 */
		get angle(): number;
		/**
		 * Returns the pattern angle.
		 *
		 * @deprecated Use angle instead.
		 * @return {Number} The angle in radians.
		 */
		getAngle(): number;
		/**
		 * Sets the pattern angle.
		 *
		 * @deprecated Use angle instead.
		 * @param {Number} value - The angle in radians.
		 */
		setAngle(value: number): void;
		set scale(arg: number);
		/**
		 * The scale.
		 *
		 * @type {Number}
		 */
		get scale(): number;

	}

	/**
	 * A gamma correction effect.
	 *
	 * @deprecated Set WebGLRenderer.outputEncoding to sRGBEncoding instead.
	 */
	export class GammaCorrectionEffect extends Effect {

		/**
		 * Constructs a new gamma correction effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Number} [options.gamma=2.0] - The gamma factor.
		 */
		constructor({
			blendFunction,
			gamma
		}?: {
			blendFunction?: BlendFunction;
			gamma?: number;
		});

	}

	/**
	 * A tilt shift effect.
	 */
	export class TiltShiftEffect extends Effect {

		/**
		 * Constructs a new tilt shift Effect
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction] - The blend function of this effect.
		 * @param {Number} [options.offset=0.0] - The relative offset of the focus area.
		 * @param {Number} [options.rotation=0.0] - The rotation of the focus area in radians.
		 * @param {Number} [options.focusArea=0.4] - The relative size of the focus area.
		 * @param {Number} [options.feather=0.3] - The softness of the focus area edges.
		 * @param {Number} [options.bias=0.06] - Deprecated.
		 * @param {KernelSize} [options.kernelSize=KernelSize.MEDIUM] - The blur kernel size.
		 * @param {Number} [options.resolutionScale=0.5] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 */
		constructor({
			blendFunction,
			offset,
			rotation,
			focusArea,
			feather,
			bias,
			kernelSize,
			resolutionScale,
			resolutionX,
			resolutionY
		}?: {
			blendFunction?: BlendFunction,
			offset?: number,
			rotation?: number,
			focusArea?: number,
			feather?: number,
			bias?: number,
			kernelSize?: KernelSize,
			resolutionScale?: number,
			resolutionX?: number,
			resolutionY?: number
		});

		/**
		 * A blur pass.
		 *
		 * @type {KawaseBlurPass}
		 */
		readonly blurPass: KawaseBlurPass;
		/**
		 * The resolution.
		 *
		 * @type {Resolution}
		 * @readonly
		 */
		get resolution(): Resolution;
		/**
		 * The rotation of the focus area in radians.
		 *
		 * @type {Number}
		 */
		get rotation(): number;
		set rotation(arg: number);
		/**
		 * The relative offset of the focus area.
		 *
		 * @type {Number}
		 */
		get offset(): number;
		set offset(arg: number);
		/**
		 * The relative size of the focus area.
		 *
		 * @type {Number}
		 */

		get focusArea(): number;
		set focusArea(arg: number);
		/**
		 * The softness of the focus area edges.
		 *
		 * @type {Number}
		 */
		get feather(): number;
		set feather(arg: number);
		/**
		 * A blend bias.
		 *
		 * @type {Number}
		 * @deprecated
		 */
		get bias(): number;
		set bias(arg: number);
	}

	/**
	 * A glitch effect.
	 *
	 * This effect can be used in conjunction with the {@link ChromaticAberrationEffect}.
	 *
	 * Reference: https://github.com/staffantan/unityglitch
	 */
	export class GlitchEffect extends Effect {

		/**
		 * Constructs a new glitch effect.
		 *
		 * TODO Change ratio to 0.15.
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Vector2} [options.chromaticAberrationOffset] - A chromatic aberration offset. If provided, the glitch effect will influence this offset.
		 * @param {Vector2} [options.delay] - The minimum and maximum delay between glitch activations in seconds.
		 * @param {Vector2} [options.duration] - The minimum and maximum duration of a glitch in seconds.
		 * @param {Vector2} [options.strength] - The strength of weak and strong glitches.
		 * @param {Texture} [options.perturbationMap] - A perturbation map. If none is provided, a noise texture will be created.
		 * @param {Number} [options.dtSize=64] - The size of the generated noise map. Will be ignored if a perturbation map is provided.
		 * @param {Number} [options.columns=0.05] - The scale of the blocky glitch columns.
		 * @param {Number} [options.ratio=0.85] - The threshold for strong glitches.
		 */
		constructor({
			blendFunction,
			chromaticAberrationOffset,
			delay,
			duration,
			strength,
			columns,
			ratio,
			perturbationMap,
			dtSize
		}?: {
			blendFunction?: BlendFunction;
			chromaticAberrationOffset?: Vector2;
			delay?: Vector2;
			duration?: Vector2;
			strength?: Vector2;
			perturbationMap?: Texture;
			dtSize?: number;
			columns?: number;
			ratio?: number;
		});

		set perturbationMap(arg: Texture);
		/**
		 * The perturbation map.
		 *
		 * @type {Texture}
		 */
		get perturbationMap(): Texture;
		/**
		 * The minimum and maximum delay between glitch activations in seconds.
		 *
		 * @type {Vector2}
		 * @deprecated Use minDelay and maxDelay instead.
		 */
		delay: Vector2;
		/**
		 * The minimum and maximum duration of a glitch in seconds.
		 *
		 * @type {Vector2}
		 * @deprecated Use minDuration and maxDuration instead.
		 */
		duration: Vector2;
		/**
		 * The strength of weak and strong glitches.
		 *
		 * @type {Vector2}
		 * @deprecated Use minStrength and maxStrength instead.
		 */
		strength: Vector2;
		/**
		 * The effect mode.
		 *
		 * @type {GlitchMode}
		 */
		mode: GlitchMode;
		/**
		 * The ratio between weak (0.0) and strong (1.0) glitches. Range is [0.0, 1.0].
		 *
		 * This value is currently being treated as a threshold for strong glitches, i.e. it's inverted.
		 *
		 * TODO Resolve inversion.
		 * @type {Number}
		 */
		ratio: number;
		/**
		 * The chromatic aberration offset.
		 *
		 * @type {Vector2}
		 */
		chromaticAberrationOffset: Vector2;
		/**
		 * Indicates whether the glitch effect is currently active.
		 *
		 * @type {Boolean}
		 */
		get active(): boolean;
		/**
		 * Indicates whether the glitch effect is currently active.
		 *
		 * @deprecated Use active instead.
		 * @return {Boolean} Whether the glitch effect is active.
		 */
		isActive(): boolean;
		set minDelay(arg: number);
		/**
		 * The minimum delay between glitch activations.
		 *
		 * @type {Number}
		 */
		get minDelay(): number;
		/**
		 * Returns the minimum delay between glitch activations.
		 *
		 * @deprecated Use minDelay instead.
		 * @return {Number} The minimum delay in seconds.
		 */
		getMinDelay(): number;
		/**
		 * Sets the minimum delay between glitch activations.
		 *
		 * @deprecated Use minDelay instead.
		 * @param {Number} value - The minimum delay in seconds.
		 */
		setMinDelay(value: number): void;
		set maxDelay(arg: number);
		/**
		 * The maximum delay between glitch activations.
		 *
		 * @type {Number}
		 */
		get maxDelay(): number;
		/**
		 * Returns the maximum delay between glitch activations.
		 *
		 * @deprecated Use maxDelay instead.
		 * @return {Number} The maximum delay in seconds.
		 */
		getMaxDelay(): number;
		/**
		 * Sets the maximum delay between glitch activations.
		 *
		 * @deprecated Use maxDelay instead.
		 * @param {Number} value - The maximum delay in seconds.
		 */
		setMaxDelay(value: number): void;
		set minDuration(arg: number);
		/**
		 * The minimum duration of sporadic glitches.
		 *
		 * @type {Number}
		 */
		get minDuration(): number;
		/**
		 * Returns the minimum duration of sporadic glitches.
		 *
		 * @deprecated Use minDuration instead.
		 * @return {Number} The minimum duration in seconds.
		 */
		getMinDuration(): number;
		/**
		 * Sets the minimum duration of sporadic glitches.
		 *
		 * @deprecated Use minDuration instead.
		 * @param {Number} value - The minimum duration in seconds.
		 */
		setMinDuration(value: number): void;
		set maxDuration(arg: number);
		/**
		 * The maximum duration of sporadic glitches.
		 *
		 * @type {Number}
		 */
		get maxDuration(): number;
		/**
		 * Returns the maximum duration of sporadic glitches.
		 *
		 * @deprecated Use maxDuration instead.
		 * @return {Number} The maximum duration in seconds.
		 */
		getMaxDuration(): number;
		/**
		 * Sets the maximum duration of sporadic glitches.
		 *
		 * @deprecated Use maxDuration instead.
		 * @param {Number} value - The maximum duration in seconds.
		 */
		setMaxDuration(value: number): void;
		set minStrength(arg: number);
		/**
		 * The strength of weak glitches.
		 *
		 * @type {Number}
		 */
		get minStrength(): number;
		/**
		 * Returns the strength of weak glitches.
		 *
		 * @deprecated Use minStrength instead.
		 * @return {Number} The strength.
		 */
		getMinStrength(): number;
		/**
		 * Sets the strength of weak glitches.
		 *
		 * @deprecated Use minStrength instead.
		 * @param {Number} value - The strength.
		 */
		setMinStrength(value: number): void;
		set maxStrength(arg: number);
		/**
		 * The strength of strong glitches.
		 *
		 * @type {Number}
		 */
		get maxStrength(): number;
		/**
		 * Returns the strength of strong glitches.
		 *
		 * @deprecated Use maxStrength instead.
		 * @return {Number} The strength.
		 */
		getMaxStrength(): number;
		/**
		 * Sets the strength of strong glitches.
		 *
		 * @deprecated Use maxStrength instead.
		 * @param {Number} value - The strength.
		 */
		setMaxStrength(value: number): void;
		/**
		 * Returns the current glitch mode.
		 *
		 * @deprecated Use mode instead.
		 * @return {GlitchMode} The mode.
		 */
		getMode(): GlitchMode;
		/**
		 * Sets the current glitch mode.
		 *
		 * @deprecated Use mode instead.
		 * @param {GlitchMode} value - The mode.
		 */
		setMode(value: GlitchMode): void;
		/**
		 * Returns the glitch ratio.
		 *
		 * @deprecated Use ratio instead.
		 * @return {Number} The ratio.
		 */
		getGlitchRatio(): number;
		/**
		 * Sets the ratio of weak (0.0) and strong (1.0) glitches.
		 *
		 * @deprecated Use ratio instead.
		 * @param {Number} value - The ratio. Range is [0.0, 1.0].
		 */
		setGlitchRatio(value: number): void;
		set columns(arg: number);
		/**
		 * The glitch column size.
		 *
		 * @type {Number}
		 */
		get columns(): number;
		/**
		 * Returns the glitch column size.
		 *
		 * @deprecated Use columns instead.
		 * @return {Number} The glitch column size.
		 */
		getGlitchColumns(): number;
		/**
		 * Sets the glitch column size.
		 *
		 * @deprecated Use columns instead.
		 * @param {Number} value - The glitch column size.
		 */
		setGlitchColumns(value: number): void;
		/**
		 * Returns the chromatic aberration offset.
		 *
		 * @deprecated Use chromaticAberrationOffset instead.
		 * @return {Vector2} The offset.
		 */
		getChromaticAberrationOffset(): Vector2;
		/**
		 * Sets the chromatic aberration offset.
		 *
		 * @deprecated Use chromaticAberrationOffset instead.
		 * @param {Vector2} value - The offset.
		 */
		setChromaticAberrationOffset(value: Vector2): void;
		/**
		 * Returns the current perturbation map.
		 *
		 * @deprecated Use perturbationMap instead.
		 * @return {Texture} The current perturbation map.
		 */
		getPerturbationMap(): Texture;
		/**
		 * Replaces the current perturbation map with the given one.
		 *
		 * The current map will be disposed if it was generated by this effect.
		 *
		 * @deprecated Use perturbationMap instead.
		 * @param {Texture} value - The new perturbation map.
		 */
		setPerturbationMap(value: Texture): void;
		/**
		 * Generates a perturbation map.
		 *
		 * @deprecated Use NoiseTexture instead.
		 * @param {Number} [value=64] - The texture size.
		 * @return {DataTexture} The perturbation map.
		 */
		generatePerturbationMap(value?: number): DataTexture;
		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime?: number
		): void;

		/**
		 * Deletes generated resources.
		 */
		dispose(): void;

	}

	/**
	 * A glitch mode enumeration.
	 *
	 * @type {Object}
	 * @property {Number} DISABLED - No glitches.
	 * @property {Number} SPORADIC - Sporadic glitches.
	 * @property {Number} CONSTANT_MILD - Constant mild glitches.
	 * @property {Number} CONSTANT_WILD - Constant wild glitches.
	 */
	export enum GlitchMode {
		DISABLED,
		SPORADIC,
		CONSTANT_MILD,
		CONSTANT_WILD,
	}

	/**
	 * A god rays effect.
	 */
	export class GodRaysEffect extends Effect {

		/**
		 * Constructs a new god rays effect.
		 *
		 * @param {Camera} [camera] - The main camera.
		 * @param {Mesh|Points} [lightSource] - The light source. Must not write depth and has to be flagged as transparent.
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function of this effect.
		 * @param {Number} [options.samples=60.0] - The number of samples per pixel.
		 * @param {Number} [options.density=0.96] - The density of the light rays.
		 * @param {Number} [options.decay=0.9] - An illumination decay factor.
		 * @param {Number} [options.weight=0.4] - A light ray weight factor.
		 * @param {Number} [options.exposure=0.6] - A constant attenuation coefficient.
		 * @param {Number} [options.clampMax=1.0] - An upper bound for the saturation of the overall effect.
		 * @param {Number} [options.resolutionScale=0.5] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - Deprecated. Use resolutionX instead.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - Deprecated. Use resolutionY instead.
		 * @param {KernelSize} [options.kernelSize=KernelSize.SMALL] - The blur kernel size. Has no effect if blur is disabled.
		 * @param {Boolean} [options.blur=true] - Whether the god rays should be blurred to reduce artifacts.
		 */
		constructor(
			camera?: Camera,
			lightSource?: Mesh | Points,
			{
				blendFunction,
				samples,
				density,
				decay,
				weight,
				exposure,
				clampMax,
				resolutionScale,
				resolutionX,
				resolutionY,
				width,
				height,
				kernelSize,
				blur
			}?: {
				blendFunction?: BlendFunction;
				samples?: number;
				density?: number;
				decay?: number;
				weight?: number;
				exposure?: number;
				clampMax?: number;
				resolutionScale?: number;
				resolutionX?: number;
				resolutionY?: number;
				width?: number;
				height?: number;
				kernelSize?: KernelSize;
				blur?: boolean;
			}
		);

		/**
		 * A blur pass that reduces aliasing artifacts and makes the light softer.
		 *
		 * This pass can be disabled to improve performance.
		 *
		 * @type {KawaseBlurPass}
		 */
		blurPass: KawaseBlurPass;
		/**
		 * Returns the blur pass that reduces aliasing artifacts and makes the light softer.
		 *
		 * @deprecated Use blurPass instead.
		 * @return {KawaseBlurPass} The blur pass.
		 */
		getBlurPass(): KawaseBlurPass;
		/**
		 * Sets the light source.
		 *
		 * @type {Mesh|Points}
		 */
		get lightSource(): Mesh | Points | null;
		set lightSource(value: Mesh | Points | null);
		/**
		 * A texture that contains the intermediate result of this effect.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		/**
		 * The depth mask material.
		 *
		 * @type {DepthMaskMaterial}
		 */
		get depthMaskMaterial(): DepthMaskMaterial;
		/**
		 * Returns the god rays texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * The internal god rays material.
		 *
		 * @type {GodRaysMaterial}
		 */
		get godRaysMaterial(): GodRaysMaterial;
		/**
		 * Returns the god rays material.
		 *
		 * @deprecated Use godRaysMaterial instead.
		 * @return {GodRaysMaterial} The material.
		 */
		getGodRaysMaterial(): GodRaysMaterial;
		/**
		 * The resolution of this effect.
		 *
		 * @type {Resolution}
		 */
		get resolution(): Resolution;
		/**
		 * Returns the resolution of this effect.
		 *
		 * @deprecated Use resolution instead.
		 * @return {GodRaysMaterial} The material.
		 */
		getResolution(): GodRaysMaterial;
		set width(arg: number);
		/**
		 * The current width of the internal render targets.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.width instead.
		 */
		get width(): number;
		set height(arg: number);
		/**
		 * The current height of the internal render targets.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.height instead.
		 */
		get height(): number;
		set dithering(arg: boolean);
		/**
		 * Indicates whether dithering is enabled.
		 *
		 * @type {Boolean}
		 * @deprecated
		 */
		get dithering(): boolean;
		set blur(arg: boolean);
		/**
		 * Indicates whether the god rays should be blurred to reduce artifacts.
		 *
		 * @type {Boolean}
		 * @deprecated Use blurPass.enabled instead.
		 */
		get blur(): boolean;
		set kernelSize(arg: KernelSize);
		/**
		 * The blur kernel size.
		 *
		 * @type {KernelSize}
		 * @deprecated Use blurPass.kernelSize instead.
		 */
		get kernelSize(): KernelSize;
		/**
		 * Returns the current resolution scale.
		 *
		 * @return {Number} The resolution scale.
		 * @deprecated Use resolution instead.
		 */
		getResolutionScale(): number;
		/**
		 * Sets the resolution scale.
		 *
		 * @param {Number} scale - The new resolution scale.
		 * @deprecated Use resolution instead.
		 */
		setResolutionScale(scale: number): void;
		/**
		 * A higher sample count improves quality at the cost of performance.
		 *
		 * @type {Number}
		 * @deprecated Use godRaysMaterial.samples instead.
		 */
		set samples(arg: number);
		/**
		 * The number of samples per pixel.
		 *
		 * @type {Number}
		 * @deprecated Use godRaysMaterial.samples instead.
		 */
		get samples(): number;
		/**
		 * Sets the depth texture.
		 *
		 * @param {Texture} depthTexture - A depth texture.
		 * @param {Number} [depthPacking=BasicDepthPacking] - The depth packing.
		 */
		setDepthTexture(depthTexture: Texture, depthPacking?: number): void;
		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime?: number
		): void;

		/**
		 * Updates the size of internal render targets.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * Performs initialization tasks.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

	}

	/**
	 * A grid effect.
	 */
	export class GridEffect extends Effect {

		/**
		 * Constructs a new grid effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.OVERLAY] - The blend function of this effect.
		 * @param {Number} [options.scale=1.0] - The scale of the grid pattern.
		 * @param {Number} [options.lineWidth=0.0] - The line width of the grid pattern.
		 */
		constructor({
			blendFunction,
			scale,
			lineWidth
		}?: {
			blendFunction?: BlendFunction;
			scale?: number;
			lineWidth?: number;
		});

		set scale(arg: number);
		/**
		 * The scale.
		 *
		 * @type {Number}
		 */
		get scale(): number;
		set lineWidth(arg: number);
		/**
		 * The line width.
		 *
		 * @type {Number}
		 */
		get lineWidth(): number;
		/**
		 * Returns the current grid scale.
		 *
		 * @deprecated Use scale instead.
		 * @return {Number} The grid scale.
		 */
		getScale(): number;
		/**
		 * Sets the grid scale.
		 *
		 * @deprecated Use scale instead.
		 * @param {Number} value - The new grid scale.
		 */
		setScale(value: number): void;
		/**
		 * Returns the current grid line width.
		 *
		 * @deprecated Use lineWidth instead.
		 * @return {Number} The grid line width.
		 */
		getLineWidth(): number;
		/**
		 * Sets the grid line width.
		 *
		 * @deprecated Use lineWidth instead.
		 * @param {Number} value - The new grid line width.
		 */
		setLineWidth(value: number): void;
		/**
		 * Updates the size of this pass.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	/**
	 * A hue/saturation effect.
	 *
	 * Reference: https://github.com/evanw/glfx.js
	 */
	export class HueSaturationEffect extends Effect {

		/**
		 * Constructs a new hue/saturation effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Number} [options.hue=0.0] - The hue in radians.
		 * @param {Number} [options.saturation=0.0] - The saturation factor, ranging from -1 to 1, where 0 means no change.
		 */
		constructor({
			blendFunction,
			hue,
			saturation
		}?: {
			blendFunction?: BlendFunction;
			hue?: number;
			saturation?: number;
		});

		set hue(arg: number);
		/**
		 * The hue.
		 *
		 * @type {Number}
		 */
		get hue(): number;
		set saturation(arg: number);
		/**
		 * The saturation.
		 *
		 * @type {Number}
		 */
		get saturation(): number;
		/**
		 * Returns the saturation.
		 *
		 * @deprecated Use saturation instead.
		 * @return {Number} The saturation.
		 */
		getSaturation(): number;
		/**
		 * Sets the saturation.
		 *
		 * @deprecated Use saturation instead.
		 * @param {Number} value - The saturation.
		 */
		setSaturation(value: number): void;
		/**
		 * Returns the hue.
		 *
		 * @deprecated Use hue instead.
		 * @return {Number} The hue in radians.
		 */
		getHue(): number;
		/**
		 * Sets the hue.
		 *
		 * @deprecated Use hue instead.
		 * @param {Number} value - The hue in radians.
		 */
		setHue(value: number): void;

	}

	/**
	 * A 1D LUT effect.
	 */

	export class LUT1DEffect extends Effect {

		/**
		 * Constructs a new color grading effect.
		 *
		 * @param {Texture} lut - The lookup texture.
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.SET] - The blend function of this effect.
		 */
		constructor(
			lut: Texture,
			{
				blendFunction
			}?: {
				blendFunction?: BlendFunction;
			}
		);

	}
	/**
	 * A LUT effect.
	 *
	 * The tetrahedral interpolation algorithm was inspired by an implementation from OpenColorIO which is licensed under
	 * the BSD 3-Clause License.
	 *
	 * The manual trilinear interpolation algorithm is based on an implementation by Garret Johnson which is licensed under
	 * the MIT License.
	 *
	 * References:
	 * https://developer.nvidia.com/gpugems/gpugems2/part-iii-high-quality-rendering/chapter-24-using-lookup-tables-accelerate-color
	 * https://www.nvidia.com/content/GTC/posters/2010/V01-Real-Time-Color-Space-Conversion-for-High-Resolution-Video.pdf
	 * https://github.com/AcademySoftwareFoundation/OpenColorIO/blob/master/src/OpenColorIO/ops/lut3d/
	 * https://github.com/gkjohnson/threejs-sandbox/tree/master/3d-lut
	 */
	export class LUT3DEffect extends Effect {

		/**
		 * Constructs a new color grading effect.
		 *
		 * @param {Texture} lut - The lookup texture.
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.SET] - The blend function of this effect.
		 * @param {Boolean} [options.tetrahedralInterpolation=false] - Enables or disables tetrahedral interpolation.
		 * @param {ColorSpace} [options.inputColorSpace=SRGBColorSpace] - The input color space.
		 */
		constructor(
			lut: Texture,
			{
				blendFunction,
				tetrahedralInterpolation,
				inputColorSpace
			}?: {
				blendFunction?: BlendFunction;
				tetrahedralInterpolation?: boolean;
				inputColorSpace?: ColorSpace;
			}
		);

		/**
		 * Indicates whether tetrahedral interpolation is enabled. Requires a 3D LUT, disabled by default.
		 *
		 * Tetrahedral interpolation produces highly accurate results but is slower than hardware interpolation.
		 *
		 * @type {Boolean}
		 */
		get tetrahedralInterpolation(): boolean;
		set tetrahedralInterpolation(arg: boolean);
		/**
		 * The LUT.
		 *
		 * @type {Texture}
		 */
		get lut(): Texture;
		set lut(arg: Texture);
		/**
		 * Returns the current LUT.
		 *
		 * @deprecated Use lut instead.
		 * @return {Texture} The LUT.
		 */
		getLUT(): Texture;
		/**
		 * Sets the LUT.
		 *
		 * @deprecated Use lut instead.
		 * @param {Texture} value - The LUT.
		 */
		setLUT(value: Texture): void;
		/**
		 * Enables or disables tetrahedral interpolation.
		 *
		 * @deprecated Use tetrahedralInterpolation instead.
		 * @param {Boolean} value - Whether tetrahedral interpolation should be enabled.
		 */
		setTetrahedralInterpolationEnabled(value: boolean): void;

	}

	/**
	 * A noise effect.
	 */
	export class NoiseEffect extends Effect {

		/**
		 * Constructs a new noise effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function of this effect.
		 * @param {Boolean} [options.premultiply=false] - Whether the noise should be multiplied with the input colors prior to blending.
		 */
		constructor({
			blendFunction,
			premultiply
		}?: {
			blendFunction?: BlendFunction;
			premultiply?: boolean;
		});

		set premultiply(arg: boolean);
		/**
		 * Indicates whether noise will be multiplied with the input colors prior to blending.
		 *
		 * @type {Boolean}
		 */
		get premultiply(): boolean;
		/**
		 * Indicates whether noise will be multiplied with the input colors prior to blending.
		 *
		 * @deprecated Use premultiply instead.
		 * @return {Boolean} Whether noise is premultiplied.
		 */
		isPremultiplied(): boolean;
		/**
		 * Controls whether noise should be multiplied with the input colors prior to blending.
		 *
		 * @deprecated Use premultiply instead.
		 * @param {Boolean} value - Whether noise should be premultiplied.
		 */
		setPremultiplied(value: boolean): void;

	}

	/**
	 * An outline effect.
	 */
	export class OutlineEffect extends Effect {

		/**
		 * Constructs a new outline effect.
		 *
		 * @param {Scene} scene - The main scene.
		 * @param {Camera} camera - The main camera.
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function. Use `BlendFunction.ALPHA` for dark outlines.
		 * @param {Texture} [options.patternTexture=null] - A pattern texture.
		 * @param {Number} [options.patternScale=1.0] - The pattern scale.
		 * @param {Number} [options.edgeStrength=1.0] - The edge strength.
		 * @param {Number} [options.pulseSpeed=0.0] - The pulse speed. A value of zero disables the pulse effect.
		 * @param {Number} [options.visibleEdgeColor=0xffffff] - The color of visible edges.
		 * @param {Number} [options.hiddenEdgeColor=0x22090a] - The color of hidden edges.
		 * @param {KernelSize} [options.kernelSize=KernelSize.VERY_SMALL] - The blur kernel size.
		 * @param {Boolean} [options.blur=false] - Whether the outline should be blurred.
		 * @param {Boolean} [options.xRay=true] - Whether occluded parts of selected objects should be visible.
		 * @param {Number} [options.multisampling=0] - The number of samples used for multisample antialiasing. Requires WebGL 2.
		 * @param {Number} [options.resolutionScale=0.5] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - Deprecated. Use resolutionX instead.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - Deprecated. Use resolutionY instead.
		 */
		constructor(
			scene?: Scene,
			camera?: Camera,
			{
				blendFunction,
				patternTexture,
				patternScale,
				edgeStrength,
				pulseSpeed,
				visibleEdgeColor,
				hiddenEdgeColor,
				multisampling,
				resolutionScale,
				resolutionX,
				resolutionY,
				width,
				height,
				kernelSize,
				blur,
				xRay
			}?: {
				blendFunction?: BlendFunction;
				patternTexture?: Texture;
				patternScale?: number;
				edgeStrength?: number;
				pulseSpeed?: number;
				visibleEdgeColor?: number;
				hiddenEdgeColor?: number;
				multisampling?: number;
				resolutionScale?: number;
				resolutionX?: number;
				resolutionY?: number;
				width?: number;
				height?: number;
				kernelSize?: KernelSize;
				blur?: boolean;
				xRay?: boolean;
			}
		);

		set patternTexture(arg: Texture);
		/**
		 * The pattern texture. Set to `null` to disable.
		 *
		 * @type {Texture}
		 */
		get patternTexture(): Texture;
		set xRay(arg: boolean);
		/**
		 * Indicates whether X-ray mode is enabled.
		 *
		 * @type {Boolean}
		 */
		get xRay(): boolean;
		/**
		 * A blur pass.
		 *
		 * @type {KawaseBlurPass}
		 */
		blurPass: KawaseBlurPass;
		/**
		 * A selection of objects that will be outlined.
		 *
		 * The default layer of this selection is 10.
		 *
		 * @type {Selection}
		 */
		selection: Selection;
		/**
		 * The pulse speed. Set to 0 to disable.
		 *
		 * @type {Number}
		 */
		pulseSpeed: number;
		/**
		 * The resolution of this effect.
		 *
		 * @type {Resolution}
		 */
		get resolution(): Resolution;
		/**
		 * Returns the resolution.
		 *
		 * @return {Resizer} The resolution.
		 */
		getResolution(): Resizer;
		set patternScale(arg: number);
		/**
		 * The pattern scale.
		 *
		 * @type {Number}
		 */
		get patternScale(): number;
		set edgeStrength(arg: number);
		/**
		 * The edge strength.
		 *
		 * @type {Number}
		 */
		get edgeStrength(): number;
		set visibleEdgeColor(arg: Color);
		/**
		 * The visible edge color.
		 *
		 * @type {Color}
		 */
		get visibleEdgeColor(): Color;
		set hiddenEdgeColor(arg: Color);
		/**
		 * The hidden edge color.
		 *
		 * @type {Color}
		 */
		get hiddenEdgeColor(): Color;
		/**
		 * The amount of MSAA samples.
		 *
		 * Requires WebGL 2. Set to zero to disable multisampling.
		 *
		 * @experimental Requires three >= r138.
		 * @type {Number}
		 */
		get multisampling(): number;
		set multisampling(arg: number);
		/**
		 * Returns the blur pass.
		 *
		 * @deprecated Use blurPass instead.
		 * @return {KawaseBlurPass} The blur pass.
		 */
		getBlurPass(): KawaseBlurPass;
		/**
		 * Returns the selection.
		 *
		 * @deprecated Use selection instead.
		 * @return {Selection} The selection.
		 */
		getSelection(): Selection;
		/**
		 * Returns the pulse speed.
		 *
		 * @deprecated Use pulseSpeed instead.
		 * @return {Number} The speed.
		 */
		getPulseSpeed(): number;
		/**
		 * Sets the pulse speed. Set to zero to disable.
		 *
		 * @deprecated Use pulseSpeed instead.
		 * @param {Number} value - The speed.
		 */
		setPulseSpeed(value: number): void;
		set width(arg: number);
		/**
		 * The current width of the internal render targets.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.width instead.
		 */
		get width(): number;
		set height(arg: number);
		/**
		 * The current height of the internal render targets.
		 *
		 * @type {Number}
		 * @deprecated Use resolution.height instead.
		 */
		get height(): number;
		set selectionLayer(arg: number);
		/**
		 * The selection layer.
		 *
		 * @type {Number}
		 * @deprecated Use selection.layer instead.
		 */
		get selectionLayer(): number;
		set dithering(arg: boolean);
		/**
		 * Indicates whether dithering is enabled.
		 *
		 * @type {Boolean}
		 * @deprecated
		 */
		get dithering(): boolean;
		set kernelSize(arg: KernelSize);
		/**
		 * The blur kernel size.
		 *
		 * @type {KernelSize}
		 * @deprecated Use blurPass.kernelSize instead.
		 */
		get kernelSize(): KernelSize;
		set blur(arg: boolean);
		/**
		 * Indicates whether the outlines should be blurred.
		 *
		 * @type {Boolean}
		 * @deprecated Use blurPass.enabled instead.
		 */
		get blur(): boolean;
		/**
		 * Indicates whether X-ray mode is enabled.
		 *
		 * @deprecated Use xRay instead.
		 * @return {Boolean} Whether X-ray mode is enabled.
		 */
		isXRayEnabled(): boolean;
		/**
		 * Enables or disables X-ray outlines.
		 *
		 * @deprecated Use xRay instead.
		 * @param {Boolean} value - Whether X-ray should be enabled.
		 */
		setXRayEnabled(value: boolean): void;
		/**
		 * Sets the pattern texture.
		 *
		 * @deprecated Use patternTexture instead.
		 * @param {Texture} value - The new texture.
		 */
		setPatternTexture(value: Texture): void;
		/**
		 * Returns the current resolution scale.
		 *
		 * @return {Number} The resolution scale.
		 * @deprecated Use resolution instead.
		 */
		getResolutionScale(): number;
		/**
		 * Sets the resolution scale.
		 *
		 * @param {Number} scale - The new resolution scale.
		 * @deprecated Use resolution instead.
		 */
		setResolutionScale(scale: number): void;
		/**
		 * Clears the current selection and selects a list of objects.
		 *
		 * @param {Object3D[]} objects - The objects that should be outlined. This array will be copied.
		 * @return {OutlineEffect} This pass.
		 * @deprecated Use selection.set() instead.
		 */
		setSelection(objects: Object3D[]): OutlineEffect;
		/**
		 * Clears the list of selected objects.
		 *
		 * @return {OutlineEffect} This pass.
		 * @deprecated Use selection.clear() instead.
		 */
		clearSelection(): OutlineEffect;
		/**
		 * Selects an object.
		 *
		 * @param {Object3D} object - The object that should be outlined.
		 * @return {OutlineEffect} This pass.
		 * @deprecated Use selection.add() instead.
		 */
		selectObject(object: Object3D): OutlineEffect;
		/**
		 * Deselects an object.
		 *
		 * @param {Object3D} object - The object that should no longer be outlined.
		 * @return {OutlineEffect} This pass.
		 * @deprecated Use selection.delete() instead.
		 */
		deselectObject(object: Object3D): OutlineEffect;
		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime?: number
		): void;

		/**
		 * Updates the size of internal render targets.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * Performs initialization tasks.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

	}

	/**
	 * A pixelation effect.
	 *
	 * Warning: This effect cannot be merged with convolution effects.
	 */
	export class PixelationEffect extends Effect {

		/**
		 * Constructs a new pixelation effect.
		 *
		 * @param {Number} [granularity=30.0] - The pixel granularity.
		 */
		constructor(granularity?: number);
		set granularity(arg: number);
		/**
		 * The pixel granularity.
		 *
		 * A higher value yields coarser visuals.
		 *
		 * @type {Number}
		 */
		get granularity(): number;
		/**
		 * Returns the pixel granularity.
		 *
		 * @deprecated Use granularity instead.
		 * @return {Number} The granularity.
		 */
		getGranularity(): number;
		/**
		 * Sets the pixel granularity.
		 *
		 * @deprecated Use granularity instead.
		 * @param {Number} value - The new granularity.
		 */
		setGranularity(value: number): void;
		/**
		 * Updates the granularity.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

	}

	/**
	 * Depth of Field shader v2.4.
	 *
	 * Yields more realistic results but is also more demanding.
	 *
	 * Original shader code by Martins Upitis:
	 *	http://blenderartists.org/forum/showthread.php?237488-GLSL-depth-of-field-with-bokeh-v2-4-(update)
	 *
	 * @deprecated Use DepthOfFieldEffect instead.
	 */
	export class RealisticBokehEffect extends Effect {

		/**
		 * Constructs a new bokeh effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Number} [options.focus=1.0] - The focus distance in world units.
		 * @param {Number} [options.focalLength=24.0] - The focal length of the main camera.
		 * @param {Number} [options.fStop=0.9] - The ratio of the lens focal length to the diameter of the entrance pupil (aperture).
		 * @param {Number} [options.luminanceThreshold=0.5] - A luminance threshold.
		 * @param {Number} [options.luminanceGain=2.0] - A luminance gain factor.
		 * @param {Number} [options.bias=0.5] - A blur bias.
		 * @param {Number} [options.fringe=0.7] - A blur offset.
		 * @param {Number} [options.maxBlur=1.0] - The maximum blur strength.
		 * @param {Boolean} [options.rings=3] - The number of blur iterations.
		 * @param {Boolean} [options.samples=2] - The amount of samples taken per ring.
		 * @param {Boolean} [options.showFocus=false] - Whether the focal point should be highlighted. Useful for debugging.
		 * @param {Boolean} [options.manualDoF=false] - Enables manual control over the depth of field.
		 * @param {Boolean} [options.pentagon=false] - Enables pentagonal blur shapes. Requires a high number of rings and samples.
		 */
		constructor({
			blendFunction,
			focus,
			focalLength,
			fStop,
			luminanceThreshold,
			luminanceGain,
			bias,
			fringe,
			maxBlur,
			rings,
			samples,
			showFocus,
			manualDoF,
			pentagon
		}?: {
			blendFunction?: BlendFunction;
			focus?: number;
			focalLength?: number;
			fStop?: number;
			luminanceThreshold?: number;
			luminanceGain?: number;
			bias?: number;
			fringe?: number;
			maxBlur?: number;
			rings?: boolean;
			samples?: boolean;
			showFocus?: boolean;
			manualDoF?: boolean;
			pentagon?: boolean;
		});

		set rings(arg: number);
		/**
		 * The amount of blur iterations.
		 *
		 * @type {Number}
		 */
		get rings(): number;
		set samples(arg: number);
		/**
		 * The amount of blur samples per ring.
		 *
		 * @type {Number}
		 */
		get samples(): number;
		set showFocus(arg: boolean);
		/**
		 * Indicates whether the focal point will be highlighted.
		 *
		 * @type {Boolean}
		 */
		get showFocus(): boolean;
		set manualDoF(arg: boolean);
		/**
		 * Indicates whether the Depth of Field should be calculated manually.
		 *
		 * If enabled, the Depth of Field can be adjusted via the `dof` uniform.
		 *
		 * @type {Boolean}
		 */
		get manualDoF(): boolean;
		set pentagon(arg: boolean);
		/**
		 * Indicates whether the blur shape should be pentagonal.
		 *
		 * @type {Boolean}
		 */
		get pentagon(): boolean;

	}

	/**
	 * A scanline effect.
	 *
	 * Based on an implementation by Georg 'Leviathan' Steinrohder (CC BY 3.0):
	 * http://www.truevision3d.com/forums/showcase/staticnoise_colorblackwhite_scanline_shaders-t18698.0.html
	 */
	export class ScanlineEffect extends Effect {

		/**
		 * Constructs a new scanline effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.OVERLAY] - The blend function of this effect.
		 * @param {Number} [options.density=1.25] - The scanline density.
		 */
		constructor({
			blendFunction,
			density
		}?: {
			blendFunction?: BlendFunction;
			density?: number;
		});

		set density(arg: number);
		/**
		 * The scanline density.
		 *
		 * @type {Number}
		 */
		get density(): number;
		/**
		 * Returns the current scanline density.
		 *
		 * @deprecated Use density instead.
		 * @return {Number} The scanline density.
		 */
		getDensity(): number;
		/**
		 * Sets the scanline density.
		 *
		 * @deprecated Use density instead.
		 * @param {Number} value - The new scanline density.
		 */
		setDensity(value: number): void;
		/**
		 * Updates the size of this pass.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * The scanline scroll speed. Default is 0 (disabled).
		 *
		 * @type {Number}
		 */
		get scrollSpeed(): number;
		set scrollSpeed(value: number);

	}

	/**
	 * A selective bloom effect.
	 *
	 * This effect applies bloom to selected objects only.
	 */
	export class SelectiveBloomEffect extends BloomEffect {

		/**
		 * Constructs a new selective bloom effect.
		 *
		 * @param {Scene} scene - The main scene.
		 * @param {Camera} camera - The main camera.
		 * @param {BloomEffectOptions} [options] - The options. See {@link BloomEffect} for details.
		 */
		constructor(scene?: Scene, camera?: Camera, options?: BloomEffectOptions);
		/**
		 * A selection of objects.
		 *
		 * The default layer of this selection is 11.
		 *
		 * @type {Selection}
		 */
		selection: Selection;
		/**
		 * Returns the selection.
		 *
		 * @deprecated Use selection instead.
		 * @return {Selection} The selection.
		 */
		getSelection(): Selection;
		set inverted(arg: boolean);
		/**
		 * Indicates whether the selection should be considered inverted.
		 *
		 * @type {Boolean}
		 */
		get inverted(): boolean;
		/**
		 * Indicates whether the mask is inverted.
		 *
		 * @deprecated Use inverted instead.
		 * @return {Boolean} Whether the mask is inverted.
		 */
		isInverted(): boolean;
		/**
		 * Enables or disable mask inversion.
		 *
		 * @deprecated Use inverted instead.
		 * @param {Boolean} value - Whether the mask should be inverted.
		 */
		setInverted(value: boolean): void;
		set ignoreBackground(arg: boolean);
		/**
		 * Indicates whether the background colors will be ignored.
		 *
		 * @type {Boolean}
		 */
		get ignoreBackground(): boolean;
		/**
		 * Indicates whether the background is disabled.
		 *
		 * @deprecated Use ignoreBackground instead.
		 * @return {Boolean} Whether the background is disabled.
		 */
		isBackgroundDisabled(): boolean;
		/**
		 * Enables or disables the background.
		 *
		 * @deprecated Use ignoreBackground instead.
		 * @param {Boolean} value - Whether the background should be disabled.
		 */
		setBackgroundDisabled(value: boolean): void;
		/**
		 * Sets the depth texture.
		 *
		 * @param {Texture} depthTexture - A depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing.
		 */
		setDepthTexture(
			depthTexture: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime: number
		): void;

		/**
		 * Updates the size of internal render targets.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;

		/**
		 * Performs initialization tasks.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

	}

	/**
	 * A sepia effect.
	 */
	export class SepiaEffect extends Effect {

		/**
		 * Constructs a new sepia effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Number} [options.intensity=1.0] - The intensity of the effect.
		 */
		constructor({
			blendFunction,
			intensity
		}?: {
			blendFunction?: BlendFunction;
			intensity?: number;
		});

		set intensity(arg: number);
		/**
		 * The intensity.
		 *
		 * @deprecated Use blendMode.opacity instead.
		 * @type {Number}
		 */
		get intensity(): number;
		/**
		 * Returns the current sepia intensity.
		 *
		 * @deprecated Use blendMode.opacity instead.
		 * @return {Number} The intensity.
		 */
		getIntensity(): number;
		/**
		 * Sets the sepia intensity.
		 *
		 * @deprecated Use blendMode.opacity instead.
		 * @param {Number} value - The intensity.
		 */
		setIntensity(value: number): void;

	}

	/**
	 * A shock wave effect.
	 *
	 * Based on a Gist by Jean-Philippe Sarda:
	 *	https://gist.github.com/jpsarda/33cea67a9f2ecb0a0eda
	 */
	export class ShockWaveEffect extends Effect {

		/**
		 * Constructs a new shock wave effect.
		 *
		 * @param {Camera} camera - The main camera.
		 * @param {Vector3} [position] - The world position of the shock wave.
		 * @param {Object} [options] - The options.
		 * @param {Number} [options.speed=2.0] - The animation speed.
		 * @param {Number} [options.maxRadius=1.0] - The extent of the shock wave.
		 * @param {Number} [options.waveSize=0.2] - The wave size.
		 * @param {Number} [options.amplitude=0.05] - The distortion amplitude.
		 */
		constructor(
			camera?: Camera,
			position?: Vector3,
			{
				speed,
				maxRadius,
				waveSize,
				amplitude
			}?: {
				speed?: number;
				maxRadius?: number;
				waveSize?: number;
				amplitude?: number;
			}
		);

		/**
		 * The position of the shock wave.
		 *
		 * @type {Vector3}
		 */
		position: Vector3;
		/**
		 * The speed of the shock wave animation.
		 *
		 * @type {Number}
		 */
		speed: number;
		set amplitude(arg: number);
		/**
		 * The amplitude.
		 *
		 * @type {Number}
		 */
		get amplitude(): number;
		set waveSize(arg: number);
		/**
		 * The wave size.
		 *
		 * @type {Number}
		 */
		get waveSize(): number;
		set maxRadius(arg: number);
		/**
		 * The maximum radius.
		 *
		 * @type {Number}
		 */
		get maxRadius(): number;
		set epicenter(arg: Vector3);
		/**
		 * The position of the shock wave.
		 *
		 * @type {Vector3}
		 * @deprecated Use position instead.
		 */
		get epicenter(): Vector3;
		/**
		 * Returns the position of the shock wave.
		 *
		 * @deprecated Use position instead.
		 * @return {Vector3} The position.
		 */
		getPosition(): Vector3;
		/**
		 * Sets the position of the shock wave.
		 *
		 * @deprecated Use position instead.
		 * @param {Vector3} value - The position.
		 */
		setPosition(value: Vector3): void;
		/**
		 * Returns the speed of the shock wave.
		 *
		 * @deprecated Use speed instead.
		 * @return {Number} The speed.
		 */
		getSpeed(): number;
		/**
		 * Sets the speed of the shock wave.
		 *
		 * @deprecated Use speed instead.
		 * @param {Number} value - The speed.
		 */
		setSpeed(value: number): void;
		/**
		 * Emits the shock wave.
		 */
		explode(): void;
		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [delta] - The time between the last frame and the current one in seconds.
		 */

		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			delta: number
		): void;

	}

	/**
	 * NVIDIA FXAA 3.11 by Timothy Lottes:
	 * https://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf
	 *
	 * Based on an implementation by Simon Rodriguez:
	 * https://github.com/kosua20/Rendu/blob/master/resources/common/shaders/screens/fxaa.frag
	 */
	export class FXAAEffect extends Effect {

		/**
		 * Constructs a new FXAA effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.SRC] - The blend function of this effect.
		 */
		constructor({
			blendFunction
		}?: {
			blendFunction?: BlendFunction
		});

		/**
		 * The minimum edge detection threshold. Range is [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get minEdgeThreshold(): number;
		set minEdgeThreshold(arg: number);

		/**
		 * The maximum edge detection threshold. Range is [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get maxEdgeThreshold(): number;
		set maxEdgeThreshold(arg: number);

		/**
		 * The subpixel blend quality. Range is [0.0, 1.0].
		 *
		 * @type {Number}
		 */
		get subpixelQuality(): number;
		set subpixelQuality(arg: number);

		/**
		 * The maximum amount of edge detection samples.
		 *
		 * @type {Number}
		 */
		get samples(): number;
		set samples(arg: number);

	}

	/**
	 * Subpixel Morphological Antialiasing (SMAA).
	 *
	 * https://github.com/iryoku/smaa/releases/tag/v2.8
	 */
	export class SMAAEffect extends Effect {

		/**
		 * The SMAA search image, encoded as a base64 data URL.
		 *
		 * @type {String}
		 * @deprecated
		 */
		static get searchImageDataURL(): string;
		/**
		 * The SMAA area image, encoded as a base64 data URL.
		 *
		 * @type {String}
		 * @deprecated
		 */
		static get areaImageDataURL(): string;
		/**
		 * Constructs a new SMAA effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {SMAAPreset} [options.preset=SMAAPreset.MEDIUM] - The quality preset.
		 * @param {EdgeDetectionMode} [options.edgeDetectionMode=EdgeDetectionMode.COLOR] - The edge detection mode.
		 * @param {PredicationMode} [options.predicationMode=PredicationMode.DISABLED] - The predication mode.
		 */
		constructor({
			preset,
			edgeDetectionMode,
			predicationMode
		}?: {
			preset?: SMAAPreset;
			edgeDetectionMode?: EdgeDetectionMode;
			predicationMode?: PredicationMode;
		});

		/**
		 * The edges texture.
		 *
		 * @type {Texture}
		 */
		get edgesTexture(): Texture;
		/**
		 * Returns the edges texture.
		 *
		 * @deprecated Use edgesTexture instead.
		 * @return {Texture} The texture.
		 */
		getEdgesTexture(): Texture;
		/**
		 * The edge weights texture.
		 *
		 * @type {Texture}
		 */
		get weightsTexture(): Texture;
		/**
		 * Returns the edge weights texture.
		 *
		 * @deprecated Use weightsTexture instead.
		 * @return {Texture} The texture.
		 */
		getWeightsTexture(): Texture;
		/**
		 * The edge detection material.
		 *
		 * @type {EdgeDetectionMaterial}
		 */
		get edgeDetectionMaterial(): EdgeDetectionMaterial;
		/**
		 * The edge detection material.
		 *
		 * @type {EdgeDetectionMaterial}
		 * @deprecated Use edgeDetectionMaterial instead.
		 */
		get colorEdgesMaterial(): EdgeDetectionMaterial;
		/**
		 * Returns the edge detection material.
		 *
		 * @deprecated Use edgeDetectionMaterial instead.
		 * @return {EdgeDetectionMaterial} The material.
		 */
		getEdgeDetectionMaterial(): EdgeDetectionMaterial;
		/**
		 * The edge weights material.
		 *
		 * @type {SMAAWeightsMaterial}
		 */
		get weightsMaterial(): SMAAWeightsMaterial;
		/**
		 * Returns the edge weights material.
		 *
		 * @deprecated Use weightsMaterial instead.
		 * @return {SMAAWeightsMaterial} The material.
		 */
		getWeightsMaterial(): SMAAWeightsMaterial;
		/**
		 * Sets the edge detection sensitivity.
		 *
		 * See {@link EdgeDetectionMaterial#setEdgeDetectionThreshold} for more details.
		 *
		 * @deprecated Use edgeDetectionMaterial instead.
		 * @param {Number} threshold - The edge detection sensitivity. Range: [0.05, 0.5].
		 */
		setEdgeDetectionThreshold(threshold: number): void;
		/**
		 * Sets the maximum amount of horizontal/vertical search steps.
		 *
		 * See {@link SMAAWeightsMaterial#setOrthogonalSearchSteps} for more details.
		 *
		 * @deprecated Use weightsMaterial instead.
		 * @param {Number} steps - The search steps. Range: [0, 112].
		 */
		setOrthogonalSearchSteps(steps: number): void;
		/**
		 * Applies the given quality preset.
		 *
		 * @param {SMAAPreset} preset - The preset.
		 */
		applyPreset(preset: SMAAPreset): void;
		/**
		 * Sets the depth texture.
		 *
		 * @param {Texture} depthTexture - A depth texture.
		 * @param {DepthPackingStrategies} [depthPacking=BasicDepthPacking] - The depth packing.
		 */
		setDepthTexture(
			depthTexture: Texture,
			depthPacking?: DepthPackingStrategies
		): void;

		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime?: number
		): void;

		/**
		 * Updates the size of internal render targets.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * Deletes internal render targets and textures.
		 */
		dispose(): void;

	}

	/**
	 * An enumeration of SMAA presets.
	 *
	 * @type {Object}
	 * @property {Number} LOW - Results in around 60% of the maximum quality.
	 * @property {Number} MEDIUM - Results in around 80% of the maximum quality.
	 * @property {Number} HIGH - Results in around 95% of the maximum quality.
	 * @property {Number} ULTRA - Results in around 99% of the maximum quality.
	 */
	export enum SMAAPreset {
		LOW,
		MEDIUM,
		HIGH,
		ULTRA,
	}

	/**
	 * A Screen Space Ambient Occlusion (SSAO) effect.
	 *
	 * For high quality visuals use two SSAO effect instances in a row with different radii, one for rough AO and one for
	 * fine details.
	 *
	 * This effect supports depth-aware upsampling and should be rendered at a lower resolution. The resolution should match
	 * that of the downsampled normals and depth. If you intend to render SSAO at full resolution, do not provide a
	 * downsampled `normalDepthBuffer`.
	 *
	 * It's recommended to specify a relative render resolution using the `resolutionScale` constructor parameter to avoid
	 * undesired sampling patterns.
	 *
	 * Based on "Scalable Ambient Obscurance" by Morgan McGuire et al. and "Depth-aware upsampling experiments" by Eleni
	 * Maria Stea:
	 * https://research.nvidia.com/publication/scalable-ambient-obscurance
	 * https://eleni.mutantstargoat.com/hikiko/on-depth-aware-upsampling
	 *
	 * The view position calculation is based on a shader by Norbert Nopper:
	 * https://github.com/McNopper/OpenGL/blob/master/Example28/shader/ssao.frag.glsl
	 */
	export class SSAOEffect extends Effect {

		/**
		 * Constructs a new SSAO effect.
		 *
		 * @todo Move normalBuffer to options.
		 * @param {Camera} [camera] - The main camera.
		 * @param {Texture} [normalBuffer] - A texture that contains the scene normals.
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.MULTIPLY] - The blend function of this effect.
		 * @param {Boolean} [options.distanceScaling=true] - Deprecated.
		 * @param {Boolean} [options.depthAwareUpsampling=true] - Enables or disables depth-aware upsampling. Has no effect if WebGL 2 is not supported.
		 * @param {Texture} [options.normalDepthBuffer=null] - Deprecated.
		 * @param {Number} [options.samples=9] - The amount of samples per pixel. Should not be a multiple of the ring count.
		 * @param {Number} [options.rings=7] - The amount of spiral turns in the occlusion sampling pattern. Should be a prime number.
		 * @param {Number} [options.worldDistanceThreshold] - The world distance threshold at which the occlusion effect starts to fade out.
		 * @param {Number} [options.worldDistanceFalloff] - The world distance falloff. Influences the smoothness of the occlusion cutoff.
		 * @param {Number} [options.worldProximityThreshold] - The world proximity threshold at which the occlusion starts to fade out.
		 * @param {Number} [options.worldProximityFalloff] - The world proximity falloff. Influences the smoothness of the proximity cutoff.
		 * @param {Number} [options.distanceThreshold=0.97] - Deprecated.
		 * @param {Number} [options.distanceFalloff=0.03] - Deprecated.
		 * @param {Number} [options.rangeThreshold=0.0005] - Deprecated.
		 * @param {Number} [options.rangeFalloff=0.001] - Deprecated.
		 * @param {Number} [options.minRadiusScale=0.1] - The minimum radius scale.
		 * @param {Number} [options.luminanceInfluence=0.7] - Determines how much the luminance of the scene influences the ambient occlusion.
		 * @param {Number} [options.radius=0.1825] - The occlusion sampling radius, expressed as a scale relative to the resolution. Range [1e-6, 1.0].
		 * @param {Number} [options.intensity=1.0] - The intensity of the ambient occlusion.
		 * @param {Number} [options.bias=0.025] - An occlusion bias. Eliminates artifacts caused by depth discontinuities.
		 * @param {Number} [options.fade=0.01] - Influences the smoothness of the shadows. A lower value results in higher contrast.
		 * @param {Color} [options.color=null] - The color of the ambient occlusion.
		 * @param {Number} [options.resolutionScale=1.0] - The resolution scale.
		 * @param {Number} [options.resolutionX=Resolution.AUTO_SIZE] - The horizontal resolution.
		 * @param {Number} [options.resolutionY=Resolution.AUTO_SIZE] - The vertical resolution.
		 * @param {Number} [options.width=Resolution.AUTO_SIZE] - Deprecated. Use resolutionX instead.
		 * @param {Number} [options.height=Resolution.AUTO_SIZE] - Deprecated. Use resolutionY instead.
		 */
		constructor(
			camera?: Camera,
			normalBuffer?: Texture,
			{
				blendFunction,
				distanceScaling,
				depthAwareUpsampling,
				normalDepthBuffer,
				samples,
				rings,
				worldDistanceThreshold,
				worldDistanceFalloff,
				worldProximityThreshold,
				worldProximityFalloff,
				distanceThreshold,
				distanceFalloff,
				rangeThreshold,
				rangeFalloff,
				minRadiusScale,
				luminanceInfluence,
				radius,
				intensity,
				bias,
				fade,
				color,
				resolutionScale,
				resolutionX,
				resolutionY,
				width,
				height
			}?: {
				blendFunction?: BlendFunction;
				distanceScaling?: boolean;
				depthAwareUpsampling?: boolean;
				normalDepthBuffer?: Texture;
				samples?: number;
				rings?: number;
				worldDistanceThreshold?: number;
				worldDistanceFalloff?: number;
				worldProximityThreshold?: number;
				worldProximityFalloff?: number;
				distanceThreshold?: number;
				distanceFalloff?: number;
				rangeThreshold?: number;
				rangeFalloff?: number;
				minRadiusScale?: number;
				luminanceInfluence?: number;
				radius?: number;
				intensity?: number;
				bias?: number;
				fade?: number;
				color?: Color;
				resolutionScale?: number;
				resolutionX?: number;
				resolutionY?: number;
				width?: number;
				height?: number;
			}
		);

		resolution: Resolution;
		/**
		 * Sets the normal buffer.
		 *
		 * @type {Texture}
		 */
		get normalBuffer(): Texture | null;
		set normalBuffer(value: Texture | null);
		/**
		 * Indicates whether depth-aware upsampling is enabled.
		 *
		 * @type {Boolean}
		 */
		get depthAwareUpsampling(): boolean;
		set depthAwareUpsampling(arg: boolean);
		/**
		 * The color of the ambient occlusion. Set to `null` to disable.
		 *
		 * @type {Color}
		 */
		get color(): Color;
		set color(arg: Color);
		/**
		 * Returns the resolution settings.
		 *
		 * @deprecated Use resolution instead.
		 * @return {Resolution} The resolution.
		 */
		getResolution(): Resolution;
		/**
		 * The SSAO material.
		 *
		 * @type {SSAOMaterial}
		 */
		get ssaoMaterial(): SSAOMaterial;
		/**
		 * Returns the SSAO material.
		 *
		 * @deprecated Use ssaoMaterial instead.
		 * @return {SSAOMaterial} The material.
		 */
		getSSAOMaterial(): SSAOMaterial;
		/**
		 * The amount of occlusion samples per pixel.
		 *
		 * @type {Number}
		 * @deprecated Use ssaoMaterial.samples instead.
		 */
		get samples(): number;
		set samples(arg: number);
		/**
		 * The amount of spiral turns in the occlusion sampling pattern.
		 *
		 * @type {Number}
		 * @deprecated Use ssaoMaterial.rings instead.
		 */
		get rings(): number;
		set rings(arg: number);
		/**
		 * The occlusion sampling radius.
		 *
		 * @type {Number}
		 * @deprecated Use ssaoMaterial.radius instead.
		 */
		get radius(): number;
		set radius(arg: number);
		/**
		 * The intensity.
		 *
		 * @type {Number}
		 */
		get intensity(): number;
		set intensity(arg: number);
		/**
		 * Indicates whether depth-aware upsampling is enabled.
		 *
		 * @deprecated Use depthAwareUpsampling instead.
		 * @return {Boolean} Whether depth-aware upsampling is enabled.
		 */
		isDepthAwareUpsamplingEnabled(): boolean;
		/**
		 * Enables or disables depth-aware upsampling.
		 *
		 * @deprecated Use depthAwareUpsampling instead.
		 * @param {Boolean} value - Whether depth-aware upsampling should be enabled.
		 */
		setDepthAwareUpsamplingEnabled(value: boolean): void;
		/**
		 * Indicates whether distance-based radius scaling is enabled.
		 *
		 * @type {Boolean}
		 * @deprecated Use ssaoMaterial.distanceScaling instead.
		 */
		get distanceScaling(): boolean;
		set distanceScaling(arg: boolean);
		/**
		 * Returns the color of the ambient occlusion.
		 *
		 * @deprecated Use color instead.
		 * @return {Color} The color.
		 */
		getColor(): Color;
		/**
		 * Sets the color of the ambient occlusion. Set to `null` to disable colorization.
		 *
		 * @deprecated Use color instead.
		 * @param {Color} value - The color.
		 */
		setColor(value: Color): void;
		/**
		 * Sets the occlusion distance cutoff.
		 *
		 * @deprecated Use ssaoMaterial instead.
		 * @param {Number} threshold - The distance threshold. Range [0.0, 1.0].
		 * @param {Number} falloff - The falloff. Range [0.0, 1.0].
		 */
		setDistanceCutoff(threshold: number, falloff: number): void;
		/**
		 * Sets the occlusion proximity cutoff.
		 *
		 * @deprecated Use ssaoMaterial instead.
		 * @param {Number} threshold - The proximity threshold. Range [0.0, 1.0].
		 * @param {Number} falloff - The falloff. Range [0.0, 1.0].
		 */
		setProximityCutoff(threshold: number, falloff: number): void;
		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime?: number
		): void;
		/**
		 * Sets the size.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 */
		setSize(width: number, height: number): void;
		/**
		 * The luminance influence factor. Range: [0.0, 1.0].
		 *
		 * @type {Boolean}
		 */
		get luminanceInfluence(): boolean;
		set luminanceInfluence(value: boolean);

	}

	/**
	 * A texture effect.
	 */
	export class TextureEffect extends Effect {

		/**
		 * Constructs a new texture effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Texture} [options.texture] - A texture.
		 * @param {Boolean} [options.aspectCorrection=false] - Deprecated. Adjust the texture's offset, repeat and center instead.
		 */
		constructor({
			blendFunction,
			texture,
			aspectCorrection
		}?: {
			blendFunction?: BlendFunction;
			texture?: Texture;
			aspectCorrection?: boolean;
		});

		set texture(arg: Texture);
		/**
		 * The texture.
		 *
		 * @type {Texture}
		 */
		get texture(): Texture;
		set aspectCorrection(arg: number);
		/**
		 * Indicates whether aspect correction is enabled.
		 *
		 * @type {Number}
		 * @deprecated Adjust the texture's offset, repeat, rotation and center instead.
		 */
		get aspectCorrection(): number;
		/**
		 * Returns the texture.
		 *
		 * @deprecated Use texture instead.
		 * @return {Texture} The texture.
		 */
		getTexture(): Texture;
		/**
		 * Sets the texture.
		 *
		 * @deprecated Use texture instead.
		 * @param {Texture} value - The texture.
		 */
		setTexture(value: Texture): void;
		set uvTransform(arg: boolean);
		/**
		 * Indicates whether the texture UV coordinates will be transformed using the transformation matrix of the texture.
		 *
		 * @type {Boolean}
		 * @deprecated Use texture.matrixAutoUpdate instead.
		 */
		get uvTransform(): boolean;
		/**
		 * Sets the swizzles that will be applied to the components of a texel before it is written to the output color.
		 *
		 * @param {ColorChannel} r - The swizzle for the `r` component.
		 * @param {ColorChannel} [g=r] - The swizzle for the `g` component.
		 * @param {ColorChannel} [b=r] - The swizzle for the `b` component.
		 * @param {ColorChannel} [a=r] - The swizzle for the `a` component.
		 */
		setTextureSwizzleRGBA(
			r: ColorChannel,
			g?: ColorChannel,
			b?: ColorChannel,
			a?: ColorChannel
		): void;

		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */

		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime: number
		): void;

		/**
		 * Performs initialization tasks.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 */

		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

	}

	/**
	 * A tone mapping mode enumeration.
	 *
	 * @type {Object}
	 * @property {Number} LINEAR - No tone mapping, only exposure.
	 * @property {Number} REINHARD - Simple Reinhard tone mapping.
	 * @property {Number} REINHARD2 - Modified Reinhard tone mapping.
	 * @property {Number} REINHARD2_ADAPTIVE - Simulates the optic nerve responding to the amount of light it is receiving.
	 * @property {Number} UNCHARTED2 - Uncharted 2 tone mapping. http://filmicworlds.com/blog/filmic-tonemapping-operators.
	 * @property {Number} OPTIMIZED_CINEON - Deprecated. Use CINEON instead.
	 * @property {Number} CINEON - Optimized filmic operator by Jim Hejl and Richard Burgess-Dawson.
	 * @property {Number} ACES_FILMIC - ACES tone mapping with a scale of 1.0/0.6.
	 * @property {Number} AGX - Filmic tone mapping. Requires three r160 or higher. https://github.com/EaryChow/AgX.
	 * @property {Number} NEUTRAL - Neutral tone mapping by Khronos. Requires three r162 or higher. https://modelviewer.dev/examples/tone-mapping.
	 */
	export enum ToneMappingMode {
		LINEAR,
		REINHARD,
		REINHARD2,
		REINHARD2_ADAPTIVE,
		UNCHARTED2,
		OPTIMIZED_CINEON,
		CINEON,
		ACES_FILMIC,
		AGX,
		NEUTRAL
	}

	/**
	 * A tone mapping effect.
	 *
	 * Note: `ToneMappingMode.REINHARD2_ADAPTIVE` requires support for `EXT_shader_texture_lod`.
	 *
	 * Reference:
	 * GDC2007 - Wolfgang Engel, Post-Processing Pipeline
	 * http://perso.univ-lyon1.fr/jean-claude.iehl/Public/educ/GAMA/2007/gdc07/Post-Processing_Pipeline.pdf
	 */
	export class ToneMappingEffect extends Effect {

		/**
		 * Constructs a new tone mapping effect.
		 *
		 * The additional parameters only affect the Reinhard2 operator.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {Boolean} [options.adaptive=false] - Deprecated. Use mode instead.
		 * @param {ToneMappingMode} [options.mode=ToneMappingMode.ACES_FILMIC] - The tone mapping mode.
		 * @param {Number} [options.resolution=256] - The resolution of the luminance texture. Must be a power of two.
		 * @param {Number} [options.maxLuminance=4.0] - Deprecated. Same as whitePoint.
		 * @param {Number} [options.whitePoint=4.0] - The white point.
		 * @param {Number} [options.middleGrey=0.6] - The middle grey factor.
		 * @param {Number} [options.minLuminance=0.01] - The minimum luminance. Prevents very high exposure in dark scenes.
		 * @param {Number} [options.averageLuminance=1.0] - The average luminance. Used for the non-adaptive Reinhard operator.
		 * @param {Number} [options.adaptationRate=1.0] - The luminance adaptation rate.
		 */
		constructor({
			blendFunction,
			adaptive,
			mode,
			resolution,
			maxLuminance,
			whitePoint,
			middleGrey,
			minLuminance,
			averageLuminance,
			adaptationRate
		}?: {
			blendFunction?: BlendFunction;
			adaptive?: boolean;
			mode?: ToneMappingMode;
			resolution?: number;
			maxLuminance?: number;
			whitePoint?: number;
			middleGrey?: number;
			minLuminance?: number;
			averageLuminance?: number;
			adaptationRate?: number;
		});

		set resolution(arg: number);
		/**
		 * The resolution of the luminance texture. Must be a power of two.
		 *
		 * @type {Number}
		 */
		get resolution(): number;
		set mode(arg: ToneMappingMode);
		/**
		 * The tone mapping mode.
		 *
		 * @type {ToneMappingMode}
		 */
		get mode(): ToneMappingMode;
		/**
		 * The white point. Default is `16.0`.
		 *
		 * Only applies to Reinhard2 (Modified & Adaptive).
		 *
		 * @type {Number}
		 */
		get whitePoint(): number;
		/**
		 * The middle grey factor. Default is `0.6`.
		 *
		 * Only applies to Reinhard2 (Modified & Adaptive).
		 *
		 * @type {Number}
		 */
		get middleGrey(): number;
		/**
		 * The average luminance.
		 *
		 * Only applies to Reinhard2 (Modified).
		 *
		 * @type {Number}
		 */
		get averageLuminance(): number;
		/**
		 * Returns the current tone mapping mode.
		 *
		 * @deprecated Use mode instead.
		 * @return {ToneMappingMode} The tone mapping mode.
		 */
		getMode(): ToneMappingMode;
		/**
		 * Sets the tone mapping mode.
		 *
		 * @deprecated Use mode instead.
		 * @param {ToneMappingMode} value - The tone mapping mode.
		 */
		setMode(value: ToneMappingMode): void;
		/**
		 * The adaptive luminance material.
		 *
		 * @type {AdaptiveLuminanceMaterial}
		 */
		get adaptiveLuminanceMaterial(): AdaptiveLuminanceMaterial;
		/**
		 * Returns the adaptive luminance material.
		 *
		 * @deprecated Use adaptiveLuminanceMaterial instead.
		 * @return {AdaptiveLuminanceMaterial} The material.
		 */
		getAdaptiveLuminanceMaterial(): AdaptiveLuminanceMaterial;
		/**
		 * Returns the resolution of the luminance texture.
		 *
		 * @deprecated Use resolution instead.
		 * @return {Number} The resolution.
		 */
		getResolution(): number;
		/**
		 * Sets the resolution of the luminance texture. Must be a power of two.
		 *
		 * @deprecated Use resolution instead.
		 * @param {Number} value - The resolution.
		 */
		setResolution(value: number): void;
		set adaptive(arg: boolean);
		/**
		 * Indicates whether this pass uses adaptive luminance.
		 *
		 * @type {Boolean}
		 * @deprecated Use mode instead.
		 */
		get adaptive(): boolean;
		set adaptationRate(arg: number);
		/**
		 * The luminance adaptation rate.
		 *
		 * @type {Number}
		 * @deprecated Use adaptiveLuminanceMaterial.adaptationRate instead.
		 */
		get adaptationRate(): number;
		set distinction(arg: number);
		/**
		 * @type {Number}
		 * @deprecated
		 */
		get distinction(): number;
		/**
		 * Updates this effect.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.
		 * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.
		 */
		update(
			renderer: WebGLRenderer,
			inputBuffer: WebGLRenderTarget,
			deltaTime?: number
		): void;

		/**
		 * Performs initialization tasks.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.
		 * @param {Number} frameBufferType - The type of the main frame buffers.
		 */
		initialize(
			renderer: WebGLRenderer,
			alpha: boolean,
			frameBufferType: number
		): void;

	}

	/**
	 * An enumeration of Vignette techniques.
	 *
	 * @type {Object}
	 * @property {Number} DEFAULT - Produces a dusty look.
	 * @property {Number} ESKIL - Produces a burned look.
	 */
	export enum VignetteTechnique {
		DEFAULT,
		ESKIL,
	}
	/**
	 * A Vignette effect.
	 */
	export class VignetteEffect extends Effect {

		/**
		 * Constructs a new Vignette effect.
		 *
		 * @param {Object} [options] - The options.
		 * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.
		 * @param {VignetteTechnique} [options.technique=VignetteTechnique.DEFAULT] - The Vignette technique.
		 * @param {Boolean} [options.eskil=false] - Deprecated. Use technique instead.
		 * @param {Number} [options.offset=0.5] - The Vignette offset.
		 * @param {Number} [options.darkness=0.5] - The Vignette darkness.
		 */
		constructor({
			blendFunction,
			technique,
			eskil,
			offset,
			darkness
		}?: {
			blendFunction?: BlendFunction;
			technique?: VignetteTechnique;
			eskil?: boolean;
			offset?: number;
			darkness?: number;
		});

		set technique(arg: VignetteTechnique);
		/**
		 * The Vignette technique.
		 *
		 * @type {VignetteTechnique}
		 */
		get technique(): VignetteTechnique;
		/**
		 * Indicates whether Eskil's Vignette technique is enabled.
		 *
		 * @type {Boolean}
		 * @deprecated Use technique instead.
		 */
		set eskil(arg: boolean);
		/**
		 * Indicates whether Eskil's Vignette technique is enabled.
		 *
		 * @type {Boolean}
		 * @deprecated Use technique instead.
		 */
		get eskil(): boolean;
		/**
		 * Returns the Vignette technique.
		 *
		 * @deprecated Use technique instead.
		 * @return {VignetteTechnique} The technique.
		 */
		getTechnique(): VignetteTechnique;
		/**
		 * Sets the Vignette technique.
		 *
		 * @deprecated Use technique instead.
		 * @param {VignetteTechnique} value - The technique.
		 */
		setTechnique(value: VignetteTechnique): void;
		set offset(arg: number);
		/**
		 * The Vignette offset.
		 *
		 * @type {Number}
		 */
		get offset(): number;
		/**
		 * Returns the Vignette offset.
		 *
		 * @deprecated Use offset instead.
		 * @return {Number} The offset.
		 */
		getOffset(): number;
		/**
		 * Sets the Vignette offset.
		 *
		 * @deprecated Use offset instead.
		 * @param {Number} value - The offset.
		 */
		setOffset(value: number): void;
		set darkness(arg: number);
		/**
		 * The Vignette darkness.
		 *
		 * @type {Number}
		 */
		get darkness(): number;
		/**
		 * Returns the Vignette darkness.
		 *
		 * @deprecated Use darkness instead.
		 * @return {Number} The darkness.
		 */
		getDarkness(): number;
		/**
		 * Sets the Vignette darkness.
		 *
		 * @deprecated Use darkness instead.
		 * @param {Number} value - The darkness.
		 */
		setDarkness(value: number): void;

	}

	/**
	 * An enumeration of LUT worker operations.
	 *
	 * @type {Object}
	 * @property {String} SCALE_UP - Tetrahedral upscale operation.
	 */
	export enum LUTOperation {
		SCALE_UP = "lut.scaleup",
	}

	/**
	 * A tetrahedral upscaler that can be used to augment 3D LUTs.
	 *
	 * Based on an implementation by Garrett Johnson:
	 * https://github.com/gkjohnson/threejs-sandbox/blob/master/3d-lut/src/TetrahedralUpscaler.js
	 */
	export class TetrahedralUpscaler {

		/**
		 * Expands the given data to the target size.
		 *
		 * @param {ArrayBufferView} data - The input RGBA data. Assumed to be cubic.
		 * @param {Number} size - The target size.
		 * @return {ArrayBufferView} The new data.
		 */
		static expand(data: ArrayBufferView, size: number): ArrayBufferView;

	}

	/**
	 * SMAA area image data.
	 *
	 * This texture allows to obtain the area for a certain pattern and distances to the left and right of identified lines.
	 *
	 * Based on the official python scripts:
	 *	https://github.com/iryoku/smaa/tree/master/Scripts
	 */
	export class SMAAAreaImageData {

		/**
		 * Creates a new area image.
		 *
		 * @return {RawImageData} The generated image data.
		 */
		static generate(): RawImageData;

	}

	/**
	 * An SMAA image generator.
	 *
	 * This class uses a worker thread to generate the search and area images. The generated data URLs will be cached using
	 * localStorage, if available. To disable caching use {@link SMAAImageGenerator.setCacheEnabled}.
	 */
	export class SMAAImageGenerator {

		/**
		 * Indicates whether data image caching is disabled.
		 *
		 * @type {Boolean}
		 * @deprecated Use setCacheEnabled() instead.
		 */
		disableCache: boolean;
		/**
		 * Enables or disables caching via localStorage.
		 *
		 * @param {Boolean} value - Whether the cache should be enabled.
		 */
		setCacheEnabled(value: boolean): void;
		/**
		 * Generates the SMAA data images.
		 *
		 * @example
		 * SMAAImageGenerator.generate().then(([search, area]) => {
		 *		const smaaEffect = new SMAAEffect(search, area);
		 * });
		 * @return {Promise<Image[]>} A promise that returns the search image and area image as a pair.
		 */
		generate(): Promise<
		(new (width?: number, height?: number) => HTMLImageElement)[]
		>;

	}

	/**
	 * SMAA search image data.
	 *
	 * This image stores information about how many pixels the line search algorithm must advance in the last step.
	 *
	 * Based on the official python scripts:
	 *	https://github.com/iryoku/smaa/tree/master/Scripts
	 */
	export class SMAASearchImageData {

		/**
		 * Creates a new search image.
		 *
		 * @return {RawImageData} The generated image data.
		 */
		static generate(): RawImageData;

	}

	/**
	 * A 3D lookup texture (LUT).
	 *
	 * This texture can be used as-is in a WebGL 2 context. It can also be converted into a 2D texture.
	 */
	export class LookupTexture extends Data3DTexture {

		/**
		 * Creates a new 3D LUT by copying a given LUT.
		 *
		 * Common image-based textures will be converted into 3D data textures.
		 *
		 * @param {Texture} texture - The LUT. Assumed to be cubic.
		 * @return {LookupTexture} A new 3D LUT.
		 */
		static from(texture: Texture): LookupTexture;
		/**
		 * Creates a neutral 3D LUT.
		 *
		 * @param {Number} size - The sidelength.
		 * @return {LookupTexture} A neutral 3D LUT.
		 */
		static createNeutral(size: number): LookupTexture;
		/**
		 * Constructs a cubic 3D lookup texture.
		 *
		 * @param {TypedArray} data - The pixel data. The default format is RGBA.
		 * @param {Number} size - The sidelength.
		 */
		constructor(data: ArrayBufferView, size: number);
		/**
		 * The lower bounds of the input domain.
		 *
		 * @type {Vector3}
		 */
		domainMin: Vector3;
		/**
		 * The upper bounds of the input domain.
		 *
		 * @type {Vector3}
		 */
		domainMax: Vector3;
		/**
		 * Indicates that this is an instance of LookupTexture3D.
		 *
		 * @type {Boolean}
		 * @deprecated
		 */
		get isLookupTexture3D(): boolean;
		/**
		 * Scales this LUT up to a given target size using tetrahedral interpolation.
		 *
		 * @param {Number} size - The target sidelength.
		 * @param {Boolean} [transferData=true] - Extra fast mode. Set to false to keep the original data intact.
		 * @return {Promise<LookupTexture>} A promise that resolves with a new LUT upon completion.
		 */
		scaleUp(size: number, transferData?: boolean): Promise<LookupTexture>;
		/**
		 * Applies the given LUT to this one.
		 *
		 * @param {LookupTexture} lut - A LUT. Must have the same dimensions, type and format as this LUT.
		 * @return {LookupTexture} This texture.
		 */
		applyLUT(lut: LookupTexture): LookupTexture;
		/**
		 * Converts the LUT data into unsigned byte data.
		 *
		 * This is a lossy operation which should only be performed after all other transformations have been applied.
		 *
		 * @return {LookupTexture} This texture.
		 */
		convertToUint8(): LookupTexture;
		/**
		 * Converts the LUT data into float data.
		 *
		 * @return {LookupTexture} This texture.
		 */
		convertToFloat(): LookupTexture;
		/**
		 * Converts this LUT into RGBA data.
		 *
		 * @deprecated LUTs are RGBA by default since three r137.
		 * @return {LookupTexture} This texture.
		 */
		convertToRGBA(): LookupTexture;
		/**
		 * Converts the output of this LUT into sRGB color space.
		 *
		 * @return {LookupTexture} This texture.
		 */
		convertLinearToSRGB(): LookupTexture;
		/**
		 * Converts the output of this LUT into linear color space.
		 *
		 * @return {LookupTexture} This texture.
		 */
		convertSRGBToLinear(): LookupTexture;
		/**
		 * Converts this LUT into a 2D data texture.
		 *
		 * Please note that custom input domains are not carried over to 2D textures.
		 *
		 * @return {DataTexture} The texture.
		 */
		toDataTexture(): DataTexture;

	}

	export type LookupTexture3D = LookupTexture;

	/**
	 * A simple noise texture.
	 */
	export class NoiseTexture extends DataTexture {

		/**
		 * Constructs a new noise texture.
		 *
		 * The texture format can be either `LuminanceFormat` or `RGBAFormat`. Additionally, the formats `RedFormat` and
		 * `RGFormat` can be used in a WebGL 2 context.
		 *
		 * @param {Number} width - The width.
		 * @param {Number} height - The height.
		 * @param {Number} [format=LuminanceFormat] - The texture format.
		 * @param {Number} [type=UnsignedByteType] - The texture type.
		 */
		constructor(width: number, height: number, format?: number, type?: number);

	}

	/**
	 * An ASCII character lookup texture.
	 */
	export class ASCIITexture extends CanvasTexture {

		/**
		 * Constructs a new ASCII texture.
		 *
		 * @param {Object} [options] - The options.
		 * @param {String} [options.characters] - The character set to render. Defaults to a common ASCII art charset.
		 * @param {String} [options.font="Arial"] - The font.
		 * @param {Number} [options.fontSize=54] - The font size in pixels.
		 * @param {Number} [options.size=1024] - The texture size.
		 * @param {Number} [options.cellCount=16] - The cell count along each side of the texture.
		 */
		constructor({
			characters,
			font,
			fontSize,
			size,
			cellCount
		}?: {
			characters?: string;
			font?: string;
			fontSize?: number;
			size?: number;
			cellCount?: number;
		});

		/**
		 * The amount of characters in this texture.
		 *
		 * @type {Number}
		 * @readonly
		 */
		readonly characterCount: number;
		/**
		 * The cell count along each side of the texture.
		 *
		 * @type {Number}
		 * @readonly
		 */
		readonly cellCount: number;

	}

	/**
	 * A container for raw RGBA image data.
	 *
	 * @implements {ImageData}
	 */
	export class RawImageData implements ImageData {

		/**
		 * Creates a new image data container.
		 *
		 * @param {ImageData|Image} image - An image or plain image data.
		 * @return {RawImageData} The image data.
		 */
		static from(
			image:
			| ImageData
			| (new (width?: number, height?: number) => HTMLImageElement)
		): RawImageData;

		/**
		 * Constructs a new image data container.
		 *
		 * @param {Number} [width=0] - The width of the image.
		 * @param {Number} [height=0] - The height of the image.
		 * @param {Uint8ClampedArray} [data=null] - The image data.
		 */
		constructor(width?: number, height?: number, data?: Uint8ClampedArray);
        colorSpace: PredefinedColorSpace;
		/**
		 * The width of the image.
		 *
		 * @type {Number}
		 */
		width: number;
		/**
		 * The height of the image.
		 *
		 * @type {Number}
		 */
		height: number;
		/**
		 * The RGBA image data.
		 *
		 * @type {Uint8ClampedArray}
		 */
		data: Uint8ClampedArray;
		/**
		 * Creates a canvas from this image data.
		 *
		 * @return {HTMLCanvasElement} The canvas, or null if it couldn't be created.
		 */
		toCanvas(): HTMLCanvasElement;

	}

	/**
	 * An SMAA image loader.
	 *
	 * @deprecated Preloading the SMAA lookup textures is no longer required.
	 * @experimental Added for testing, API might change in patch or minor releases. Requires three >= r108.
	 */
	export class SMAAImageLoader extends Loader {

		/**
		 * Loads the SMAA data images.
		 *
		 * @param {Function} [onLoad] - A callback that receives the search image and area image as a pair.
		 * @param {Function} [onError] - An error callback that receives the URL of the image that failed to load.
		 * @return {Promise<Image[]>} A promise that returns the search image and area image as a pair.
		 */
		load(
			url?: string | null,
			onLoad?: Function,
			onError?: Function
		): Promise<(new (width?: number, height?: number) => HTMLImageElement)[]>;

	}

	/**
	 * A 3D LUT loader that supports the .cube file format.
	 *
	 * Based on an implementation by Garrett Johnson:
	 * https://github.com/gkjohnson/threejs-sandbox/tree/master/3d-lut
	 *
	 * For more details see:
	 * https://wwwimages2.adobe.com/content/dam/acom/en/products/speedgrade/cc/pdfs/cube-lut-specification-1.0.pdf
	 */
	export class LUTCubeLoader extends Loader {

		/**
		 * Loads a LUT.
		 *
		 * @param {String} url - The URL of the CUBE-file.
		 * @param {Function} [onLoad] - A callback that receives the loaded lookup texture.
		 * @param {Function} [onProgress] - A progress callback that receives the XMLHttpRequest instance.
		 * @param {Function} [onError] - An error callback that receives the URL of the file that failed to load.
		 * @return {Promise<LookupTexture>} A promise that returns the lookup texture.
		 */
		load(
			url: string,
			onLoad?: Function,
			onProgress?: Function,
			onError?: Function
		): Promise<LookupTexture>;

		/**
		 * Parses the given data.
		 *
		 * @param {String} input - The LUT data.
		 * @return {LookupTexture} The lookup texture.
		 * @throws {Error} Fails if the data is invalid.
		 */
		parse(input: string): LookupTexture;

	}

	/**
	 * A 3D LUT loader that supports the .3dl file format.
	 *
	 * Based on an implementation by Garrett Johnson:
	 * https://github.com/gkjohnson/threejs-sandbox/tree/master/3d-lut
	 *
	 * For more details see:
	 * http://download.autodesk.com/us/systemdocs/help/2011/lustre/index.html?url=./files/WSc4e151a45a3b785a24c3d9a411df9298473-7ffd.htm,topicNumber=d0e9492
	 */
	export class LUT3dlLoader extends Loader {

		/**
		 * Loads a LUT.
		 *
		 * @param {String} url - The URL of the 3dl-file.
		 * @param {Function} [onLoad] - A callback that receives the loaded lookup texture.
		 * @param {Function} [onProgress] - A progress callback that receives the XMLHttpRequest instance.
		 * @param {Function} [onError] - An error callback that receives the URL of the file that failed to load.
		 * @return {Promise<LookupTexture>} A promise that returns the lookup texture.
		 */
		load(
			url: string,
			onLoad?: Function,
			onProgress?: Function,
			onError?: Function
		): Promise<LookupTexture>;

		/**
		 * Parses the given data.
		 *
		 * @param {String} input - The LUT data.
		 * @return {LookupTexture} The lookup texture.
		 * @throws {Error} Fails if the data is invalid.
		 */
		parse(input: string): LookupTexture;

	}

	/**
	 * Determines the texture inline decoding.
	 *
	 * @param {Texture} texture - A texture.
	 * @param {Boolean} isWebGL2 - Whether the context is WebGL 2.
	 * @return {String} The decoding.
	 * @ignore
	 */
	export function getTextureDecoding(
		texture: Texture,
		isWebGL2: boolean
	): string;

	/**
	 * Converts orthographic depth to view Z.
	 *
	 * @see https://github.com/mrdoob/three.js/blob/0de4e75ee65c3238957318b88ef91b6597e23c1e/src/renderers/shaders/ShaderChunk/packing.glsl.js#L42
	 * @param {Number} depth - The linear clip Z.
	 * @param {Number} near - The camera near plane.
	 * @param {Number} far - The camera far plane.
	 * @return {Number} The view Z.
	 * @ignore
	 */
	export function orthographicDepthToViewZ(
		depth: number,
		near: number,
		far: number
	): number;

	/**
	 * Converts view Z to orthographic depth.
	 *
	 * @see https://github.com/mrdoob/three.js/blob/0de4e75ee65c3238957318b88ef91b6597e23c1e/src/renderers/shaders/ShaderChunk/packing.glsl.js#L39
	 * @param {Number} viewZ - The view Z. Expected to be negative.
	 * @param {Number} near - The camera near plane.
	 * @param {Number} far - The camera far plane.
	 * @return {Number} The depth.
	 * @ignore
	 */
	export function viewZToOrthographicDepth(
		viewZ: number,
		near: number,
		far: number
	): number;

	/**
	 * A lens distortion effect.
	 *
	 * Original shader ported from https://github.com/ycw/three-lens-distortion
	 */

	export class LensDistortionEffect extends Effect {

		/**
		* Constructs a new lens distortion effect.
		*
		* @param {Object} [options] - The options.
		* @param {Vector2} [options.distortion] - The distortion value.
		* @param {Vector2} [options.principalPoint] - The center point.
		* @param {Vector2} [options.focalLength] - The focal length.
		* @param {Number} [options.skew=0] - The skew value.
		*/

		constructor({
			distortion,
			principalPoint,
			focalLength,
			skew
		}?: {
			distortion: Vector2;
			principalPoint: Vector2;
			focalLength: Vector2;
			skew?: number;
		});

		/**
		 * The radial distortion coefficients. Default is (0, 0).
		 *
		 * @type {Vector2}
		 */

		get distortion(): Vector2;
		set distortion(value: Vector2);

		/**
		 * The principal point. Default is (0, 0).
		 *
		 * @type {Vector2}
		 */

		get principalPoint(): Vector2;
		set principalPoint(value: Vector2);

		/**
		 * The focal length. Default is (1, 1).
		 *
		 * @type {Vector2}
		 */

		get focalLength(): Vector2;
		set focalLength(value: Vector2);

		/**
		 * The skew factor in radians.
		 *
		 * @type {Number}
		 */

		get skew(): number;
		set skew(value: number);

	}

}