@types/three 0.181.0 → 0.183.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Fri, 31 Oct 2025 16:38:34 GMT
+ * Last updated: Wed, 18 Feb 2026 23:03:27 GMT
  * Dependencies: [@dimforge/rapier3d-compat](https://npmjs.com/package/@dimforge/rapier3d-compat), [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/Addons.d.ts

@@ -123,8 +123,6 @@ export * from "./loaders/VTKLoader.js";
 export * from "./loaders/XYZLoader.js";
 
 export * from "./materials/LDrawConditionalLineMaterial.js";
-export * from "./materials/MeshGouraudMaterial.js";
-export * from "./materials/MeshPostProcessingMaterial.js";
 
 export * from "./math/Capsule.js";
 export * from "./math/ColorConverter.js";
@@ -225,7 +223,6 @@ export * from "./shaders/FocusShader.js";
 export * from "./shaders/FreiChenShader.js";
 export * from "./shaders/FXAAShader.js";
 export * from "./shaders/GammaCorrectionShader.js";
-export * from "./shaders/GodRaysShader.js";
 export * from "./shaders/GTAOShader.js";
 export * from "./shaders/HalftoneShader.js";
 export * from "./shaders/HorizontalBlurShader.js";

three/examples/jsm/controls/ArcballControls.d.ts

@@ -130,7 +130,7 @@ declare class ArcballControls extends Controls<ArcballControlsEventMap> {
      * @param domElement The HTML element used for event listeners. (optional)
      * @param scene The scene rendered by the camera. If not given, gizmos cannot be shown. (optional)
      */
-    constructor(camera: Camera, domElement?: HTMLElement | null, scene?: Scene | null);
+    constructor(camera: Camera, domElement?: HTMLElement | SVGElement | null, scene?: Scene | null);
 
     /**
      * Set a new mouse action by specifying the operation to be performed and a mouse/key combination. In case of

three/examples/jsm/controls/DragControls.d.ts

@@ -75,7 +75,7 @@ declare class DragControls extends Controls<DragControlsEventMap> {
      * @param camera The camera of the rendered scene.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(objects: Object3D[], camera: Camera, domElement?: HTMLElement | null);
+    constructor(objects: Object3D[], camera: Camera, domElement?: HTMLElement | SVGElement | null);
 }
 
 export { DragControls };

three/examples/jsm/controls/FirstPersonControls.d.ts

@@ -76,7 +76,7 @@ declare class FirstPersonControls extends Controls<{}> {
      * @param object The camera to be controlled.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(object: Camera, domElement?: HTMLElement);
+    constructor(object: Camera, domElement?: HTMLElement | SVGElement);
 
     /**
      * Should be called if the application window is resized.

three/examples/jsm/controls/FlyControls.d.ts

@@ -38,7 +38,7 @@ declare class FlyControls extends Controls<FlyControlsEventMap> {
      * @param object The camera to be controlled.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(object: Camera, domElement?: HTMLElement | null);
+    constructor(object: Camera, domElement?: HTMLElement | SVGElement | null);
 }
 
 export { FlyControls };

three/examples/jsm/controls/OrbitControls.d.ts

@@ -206,7 +206,10 @@ declare class OrbitControls extends Controls<OrbitControlsEventMap> {
      * is the scene itself.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(object: Camera, domElement?: HTMLElement | null);
+    constructor(object: Camera, domElement?: HTMLElement | SVGElement | null);
+
+    set cursorStyle(type: "auto" | "grab");
+    get cursorStyle(): "auto" | "grab";
 
     /**
      * Get the current vertical rotation, in radians.
@@ -245,6 +248,42 @@ declare class OrbitControls extends Controls<OrbitControlsEventMap> {
      */
     reset(): void;
 
+    /**
+     * Programmatically pan the camera.
+     *
+     * @param {number} deltaX - The horizontal pan amount in pixels.
+     * @param {number} deltaY - The vertical pan amount in pixels.
+     */
+    pan(deltaX: number, deltaY: number): void;
+
+    /**
+     * Programmatically dolly in (zoom in for perspective camera).
+     *
+     * @param {number} dollyScale - The dolly scale factor.
+     */
+    dollyIn(dollyScale: number): void;
+
+    /**
+     * Programmatically dolly out (zoom out for perspective camera).
+     *
+     * @param {number} dollyScale - The dolly scale factor.
+     */
+    dollyOut(dollyScale: number): void;
+
+    /**
+     * Programmatically rotate the camera left (around the vertical axis).
+     *
+     * @param {number} angle - The rotation angle in radians.
+     */
+    rotateLeft(angle: number): void;
+
+    /**
+     * Programmatically rotate the camera up (around the horizontal axis).
+     *
+     * @param {number} angle - The rotation angle in radians.
+     */
+    rotateUp(angle: number): void;
+
     /**
      * Update the controls. Must be called after any manual changes to the camera's transform, or in the update loop if
      * {@link .autoRotate} or {@link .enableDamping} are set. `deltaTime`, in seconds, is optional, and is only required

three/examples/jsm/controls/PointerLockControls.d.ts

@@ -47,7 +47,7 @@ declare class PointerLockControls extends Controls<PointerLockControlsEventMap>
      * @param camera The camera of the rendered scene.
      * @param domElement The HTML element used for event listeners.
      */
-    constructor(camera: Camera, domElement?: HTMLElement | null);
+    constructor(camera: Camera, domElement?: HTMLElement | SVGElement | null);
 
     /**
      * Returns the look direction of the camera.

three/examples/jsm/controls/TrackballControls.d.ts

@@ -124,7 +124,7 @@ declare class TrackballControls extends Controls<TrackballControlsEventMap> {
      * @param camera The camera of the rendered scene.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(camera: Camera, domElement?: HTMLElement | null);
+    constructor(camera: Camera, domElement?: HTMLElement | SVGElement | null);
 
     /**
      * Should be called if the application window is resized.

three/examples/jsm/controls/TransformControls.d.ts

@@ -163,7 +163,7 @@ declare class TransformControls extends Controls<TransformControlsEventMap> {
      * @param camera The camera of the rendered scene.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(camera: Camera, domElement?: HTMLElement);
+    constructor(camera: Camera, domElement?: HTMLElement | SVGElement | null);
 
     /**
      * Returns the visual representation of the controls. Add the helper to your scene to visually transform the

three/examples/jsm/effects/AnaglyphEffect.d.ts

@@ -5,6 +5,10 @@ declare class AnaglyphEffect {
 
     colorMatrixRight: Matrix3;
 
+    eyeSep: number;
+
+    planeDistance: number;
+
     setSize: (width: number, height: number) => void;
 
     render: (scene: Scene, camera: Camera) => void;

three/examples/jsm/environments/ColorEnvironment.d.ts

@@ -0,0 +1,9 @@
+import { ColorRepresentation, Scene } from "three";
+
+declare class ColorEnvironment extends Scene {
+    constructor(color?: ColorRepresentation);
+
+    dispose(): void;
+}
+
+export { ColorEnvironment };

three/examples/jsm/gpgpu/BitonicSort.d.ts

@@ -1,20 +1,20 @@
 import { Node, Renderer, StorageBufferNode } from "three/webgpu";
 
-export const getBitonicFlipIndices: (index: Node, blockHeight: Node) => Node;
+export const getBitonicFlipIndices: (index: Node, blockHeight: Node) => Node<"uvec2">;
 
-export const getBitonicDisperseIndices: (index: Node, swapSpan: Node) => Node;
+export const getBitonicDisperseIndices: (index: Node, swapSpan: Node) => Node<"uvec2">;
 
 export interface BitonicSortOptions {
     workgroupSize?: number | undefined;
 }
 
-export class BitonicSort {
-    infoStorage: StorageBufferNode;
+export class BitonicSort<TNodeType> {
+    infoStorage: StorageBufferNode<TNodeType>;
 
     swapOpCount: number;
     stepCount: number;
 
-    constructor(renderer: Renderer, dataBuffer: StorageBufferNode, options?: BitonicSortOptions);
+    constructor(renderer: Renderer, dataBuffer: StorageBufferNode<TNodeType>, options?: BitonicSortOptions);
 
     computeStep(renderer: Renderer): Promise<void>;
     compute(renderer: Renderer): Promise<void>;

three/examples/jsm/helpers/AnimationPathHelper.d.ts

@@ -0,0 +1,38 @@
+import {
+    AnimationClip,
+    BufferGeometry,
+    ColorRepresentation,
+    Line,
+    LineBasicMaterial,
+    Object3D,
+    Points,
+    PointsMaterial,
+} from "three";
+
+export interface AnimationPathHelperOptions {
+    color?: ColorRepresentation | undefined;
+    markerColor?: ColorRepresentation | undefined;
+    divisions?: number | undefined;
+    showMarkers?: boolean | undefined;
+    markerSize?: number | undefined;
+}
+
+declare class AnimationPathHelper extends Object3D {
+    readonly isAnimationPathHelper: boolean;
+
+    root: Object3D;
+    clip: AnimationClip;
+    object: Object3D;
+    divisions: number;
+
+    line: Line<BufferGeometry, LineBasicMaterial>;
+    points: Points<BufferGeometry, PointsMaterial> | null;
+
+    constructor(root: Object3D, clip: AnimationClip, object: Object3D, options?: AnimationPathHelperOptions);
+
+    setColor(color: ColorRepresentation): void;
+    setMarkerColor(color: ColorRepresentation): void;
+    dispose(): void;
+}
+
+export { AnimationPathHelper };

three/examples/jsm/helpers/ViewHelper.d.ts

@@ -1,10 +1,11 @@
 import { Camera, Object3D, Vector3, WebGLRenderer } from "three";
 
-export class ViewHelper extends Object3D {
+declare class ViewHelper extends Object3D {
     readonly isViewHelper: true;
 
     animating: boolean;
     center: Vector3;
+    location: { top: number | null; right: number; bottom: number; left: number | null };
 
     render: (renderer: WebGLRenderer) => void;
     handleClick: (event: MouseEvent) => boolean;
@@ -15,3 +16,5 @@ export class ViewHelper extends Object3D {
 
     constructor(camera: Camera, domElement: HTMLElement);
 }
+
+export { ViewHelper };

three/examples/jsm/inspector/tabs/Parameters.d.ts

@@ -1,3 +1,4 @@
+import { Item } from "../ui/Item.js";
 import { Tab } from "../ui/Tab.js";
 import { ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider } from "../ui/Values.js";
 
@@ -52,6 +53,8 @@ interface ValueColorWithParameters<
 declare class ParametersGroup {
     name: string;
 
+    paramList: Item;
+
     constructor(parameters: never, name: string);
 
     add<T, K extends keyof T>(

three/examples/jsm/inspector/ui/Item.d.ts

@@ -0,0 +1,5 @@
+export class Item {
+    domElement: HTMLDivElement;
+
+    constructor(...data: readonly unknown[]);
+}

three/examples/jsm/libs/meshopt_decoder.module.d.ts

@@ -1 +1 @@
-export * from "meshoptimizer/meshopt_decoder.module.js";
+export * from "meshoptimizer/decoder";

three/examples/jsm/lights/LightProbeGenerator.d.ts

@@ -1,10 +1,16 @@
 import { CubeTexture, LightProbe, WebGLCubeRenderTarget, WebGLRenderer } from "three";
-import { WebGPURenderer } from "three/webgpu";
+import { CubeRenderTarget, WebGPURenderer } from "three/webgpu";
 
-export namespace LightProbeGenerator {
-    function fromCubeTexture(cubeTexture: CubeTexture): LightProbe;
-    function fromCubeRenderTarget(
-        renderer: WebGLRenderer | WebGPURenderer,
+declare class LightProbeGenerator {
+    static fromCubeTexture(cubeTexture: CubeTexture): LightProbe;
+    static fromCubeRenderTarget(
+        renderer: WebGLRenderer,
         cubeRenderTarget: WebGLCubeRenderTarget,
     ): Promise<LightProbe>;
+    static fromCubeRenderTarget(
+        renderer: WebGPURenderer,
+        cubeRenderTarget: CubeRenderTarget,
+    ): Promise<LightProbe>;
 }
+
+export { LightProbeGenerator };

three/examples/jsm/loaders/ColladaLoader.d.ts

@@ -1,11 +1,34 @@
 import { Loader, Scene } from "three";
 
+export interface ColladaKinematics {
+    joints: unknown;
+    getJointValue: unknown;
+    setJointValue: unknown;
+}
+
+export interface ColladaLibrary {
+    animations: Record<string, unknown>;
+    clips: Record<string, unknown>;
+    controllers: Record<string, unknown>;
+    images: Record<string, unknown>;
+    effects: Record<string, unknown>;
+    materials: Record<string, unknown>;
+    cameras: Record<string, unknown>;
+    lights: Record<string, unknown>;
+    geometries: Record<string, unknown>;
+    nodes: Record<string, unknown>;
+    visualScenes: Record<string, unknown>;
+    kinematicsModels: Record<string, unknown>;
+    physicsModels: Record<string, unknown>;
+    kinematicsScenes: Record<string, unknown>;
+}
+
 export interface Collada {
-    kinematics: object;
-    library: object;
+    kinematics?: ColladaKinematics;
+    library?: ColladaLibrary;
     scene: Scene;
 }
 
-export class ColladaLoader extends Loader<Collada> {
-    parse(text: string, path: string): Collada;
+export class ColladaLoader extends Loader<Collada | null> {
+    parse(text: string, path: string): Collada | null;
 }

three/examples/jsm/loaders/UltraHDRLoader.d.ts

@@ -16,6 +16,13 @@ declare class UltraHDRLoader extends Loader<DataTexture> {
     setDataType(value: TextureDataType): this;
 
     parse(buffer: ArrayBuffer, onLoad: (texData: UltraHDRLoaderTextureData) => void): void;
+
+    load(
+        url: string,
+        onLoad: (data: DataTexture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): DataTexture;
 }
 
 export { UltraHDRLoader };

three/examples/jsm/loaders/VOXLoader.d.ts

@@ -1,4 +1,4 @@
-import { Data3DTexture, Loader, LoadingManager, Mesh } from "three";
+import { BufferGeometry, Data3DTexture, Loader, LoadingManager, Mesh, MeshStandardMaterial, Object3D } from "three";
 
 export interface Chunk {
     palette: number[];
@@ -6,16 +6,33 @@ export interface Chunk {
     data: Uint8Array;
 }
 
-export class VOXLoader extends Loader<Chunk[]> {
+export interface VOXLoaderResult {
+    chunks: Chunk[];
+    scene: Object3D;
+}
+
+declare class VOXLoader extends Loader<VOXLoaderResult> {
     constructor(manager?: LoadingManager);
 
-    parse(data: ArrayBuffer): object[];
+    parse(data: ArrayBuffer): VOXLoaderResult;
 }
 
-export class VOXMesh extends Mesh {
+declare function buildMesh(chunk: Chunk): Mesh<BufferGeometry, MeshStandardMaterial>;
+
+declare function buildData3DTexture(chunk: Chunk): Data3DTexture;
+
+/**
+ * @deprecated Use buildMesh() instead.
+ */
+declare class VOXMesh extends Mesh {
     constructor(chunk: Chunk);
 }
 
-export class VOXData3DTexture extends Data3DTexture {
+/**
+ * @deprecated Use buildData3DTexture() instead.
+ */
+declare class VOXData3DTexture extends Data3DTexture {
     constructor(chunk: Chunk);
 }
+
+export { buildData3DTexture, buildMesh, VOXData3DTexture, VOXLoader, VOXMesh };

three/examples/jsm/math/Octree.d.ts

@@ -1,32 +1,54 @@
-import { Box3, Layers, Object3D, Ray, Sphere, Triangle } from "three";
+import { Box3, Layers, Object3D, Ray, Sphere, Triangle, Vector3 } from "three";
 
 import { Capsule } from "./Capsule.js";
 
-export class Octree {
-    box: Box3 | null | undefined;
+interface OctreeTriangleIntersection {
+    normal: Vector3;
+    point: Vector3;
+    depth: number;
+}
+
+interface OctreeIntersection {
+    normal: Vector3;
+    depth: number;
+}
+
+interface OctreeRayIntersection {
+    distance: number;
+    triangle: Triangle;
+    position: Vector3;
+}
+
+declare class Octree {
+    box: Box3 | undefined;
     bounds: Box3;
 
-    subTrees: Octree[];
-    triangles: Triangle[];
     layers: Layers;
-
     trianglesPerLeaf: number;
     maxLevel: number;
 
-    constructor(box?: Box3 | null);
+    subTrees: Octree[];
+    triangles: Triangle[];
+
+    constructor(box?: Box3);
 
     addTriangle(triangle: Triangle): this;
     calcBox(): this;
     split(level: number): this;
     build(): this;
     getRayTriangles(ray: Ray, triangles: Triangle[]): Triangle[];
-    triangleCapsuleIntersect(capsule: Capsule, triangle: Triangle): any;
-    triangleSphereIntersect(sphere: Sphere, triangle: Triangle): any;
-    getSphereTriangles(sphere: Sphere, triangles: Triangle[]): Triangle[];
-    getCapsuleTriangles(capsule: Capsule, triangles: Triangle[]): Triangle[];
-    sphereIntersect(sphere: Sphere): any;
-    capsuleIntersect(capsule: Capsule): any;
-    rayIntersect(ray: Ray): any;
+    triangleCapsuleIntersect(capsule: Capsule, triangle: Triangle): OctreeTriangleIntersection | false;
+    triangleBoxIntersect(box: Box3, triangle: Triangle): OctreeTriangleIntersection | false;
+    triangleSphereIntersect(sphere: Sphere, triangle: Triangle): OctreeTriangleIntersection | false;
+    getSphereTriangles(sphere: Sphere, triangles: Triangle[]): void;
+    getBoxTriangles(box: Box3, triangles: Triangle[]): void;
+    getCapsuleTriangles(capsule: Capsule, triangles: Triangle[]): void;
+    boxIntersect(box: Box3): OctreeIntersection | false;
+    sphereIntersect(sphere: Sphere): OctreeIntersection | false;
+    capsuleIntersect(capsule: Capsule): OctreeIntersection | false;
+    rayIntersect(ray: Ray): OctreeRayIntersection | false;
     fromGraphNode(group: Object3D): this;
     clear(): this;
 }
+
+export { Octree };

three/examples/jsm/objects/SkyMesh.d.ts

@@ -1,15 +1,25 @@
 import { BoxGeometry, Mesh, NodeMaterial, UniformNode, Vector3 } from "three/webgpu";
 
 declare class SkyMesh extends Mesh<BoxGeometry, NodeMaterial> {
-    turbidity: UniformNode<number>;
-    rayleigh: UniformNode<number>;
-    mieCoefficient: UniformNode<number>;
-    mieDirectionalG: UniformNode<number>;
-    sunPosition: UniformNode<Vector3>;
-    upUniform: UniformNode<Vector3>;
+    turbidity: UniformNode<"float", number>;
+    rayleigh: UniformNode<"float", number>;
+    mieCoefficient: UniformNode<"float", number>;
+    mieDirectionalG: UniformNode<"float", number>;
+    sunPosition: UniformNode<"vec3", Vector3>;
+    upUniform: UniformNode<"vec3", Vector3>;
+    cloudScale: UniformNode<"float", number>;
+    cloudSpeed: UniformNode<"float", number>;
+    cloudCoverage: UniformNode<"float", number>;
+    cloudDensity: UniformNode<"float", number>;
+    cloudElevation: UniformNode<"float", number>;
 
+    /**
+     * @deprecated
+     */
     readonly isSky: true;
 
+    readonly isSkyMesh: true;
+
     constructor();
 }
 

three/examples/jsm/objects/Water2Mesh.d.ts

@@ -30,19 +30,19 @@ declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
     constructor(geometry: BufferGeometry, options: WaterMeshOptions);
 }
 
-declare class WaterNode extends TempNode {
+declare class WaterNode extends TempNode<"vec4"> {
     waterBody: WaterMesh;
 
     normalMap0: TextureNode;
     normalMap1: TextureNode;
     flowMap: TextureNode;
 
-    color: UniformNode<Color>;
-    flowDirection: UniformNode<Vector2>;
-    flowSpeed: UniformNode<number>;
-    reflectivity: UniformNode<number>;
-    scale: UniformNode<number>;
-    flowConfig: UniformNode<Vector3>;
+    color: UniformNode<"color", Color>;
+    flowDirection: UniformNode<"vec2", Vector2>;
+    flowSpeed: UniformNode<"float", number>;
+    reflectivity: UniformNode<"float", number>;
+    scale: UniformNode<"float", number>;
+    flowConfig: UniformNode<"vec3", Vector3>;
 
     constructor(options: WaterMeshOptions, waterBody: WaterMesh);
 

three/examples/jsm/objects/WaterMesh.d.ts

@@ -27,12 +27,12 @@ declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
     resolutionScale: number;
 
     waterNormals: TextureNode;
-    alpha: UniformNode<number>;
-    size: UniformNode<number>;
-    sunColor: UniformNode<Color>;
-    sunDirection: UniformNode<Vector3>;
-    waterColor: UniformNode<Color>;
-    distortionScale: UniformNode<number>;
+    alpha: UniformNode<"float", number>;
+    size: UniformNode<"float", number>;
+    sunColor: UniformNode<"color", Color>;
+    sunDirection: UniformNode<"vec3", Vector3>;
+    waterColor: UniformNode<"color", Color>;
+    distortionScale: UniformNode<"float", number>;
 
     constructor(geometry: BufferGeometry, options: WaterMeshOptions);
 }

three/examples/jsm/physics/AmmoPhysics.d.ts

@@ -2,7 +2,7 @@ import { Mesh, Object3D, Vector3 } from "three";
 
 export interface AmmoPhysicsObject {
     addScene: (scene: Object3D) => void;
-    addMesh: (mesh: Mesh, mass?: number) => void;
+    addMesh: (mesh: Mesh, mass?: number, restitution?: number) => void;
     setMeshPosition: (mesh: Mesh, position: Vector3, index?: number) => void;
 }
 

three/examples/jsm/postprocessing/EffectComposer.d.ts

@@ -1,22 +1,19 @@
-import { Clock, WebGLRenderer, WebGLRenderTarget } from "three";
-
-import { FullScreenQuad, Pass } from "./Pass.js";
+import { Timer, WebGLRenderer, WebGLRenderTarget } from "three";
+import { Pass } from "./Pass.js";
 import { ShaderPass } from "./ShaderPass.js";
 
-export { FullScreenQuad } from "./Pass.js";
-export { Pass };
-
-export class EffectComposer {
-    constructor(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
+declare class EffectComposer {
     renderer: WebGLRenderer;
     renderTarget1: WebGLRenderTarget;
     renderTarget2: WebGLRenderTarget;
     writeBuffer: WebGLRenderTarget;
     readBuffer: WebGLRenderTarget;
+    renderToScreen: boolean;
     passes: Pass[];
     copyPass: ShaderPass;
-    clock: Clock;
-    renderToScreen: boolean;
+    timer: Timer;
+
+    constructor(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
 
     swapBuffers(): void;
     addPass(pass: Pass): void;
@@ -29,3 +26,5 @@ export class EffectComposer {
     setPixelRatio(pixelRatio: number): void;
     dispose(): void;
 }
+
+export { EffectComposer };

three/examples/jsm/postprocessing/OutputPass.d.ts

@@ -1,10 +1,14 @@
-import { ShaderMaterial } from "three";
+import { IUniform, RawShaderMaterial } from "three";
 
-import { FullScreenQuad, Pass } from "./Pass.js";
+import { Pass } from "./Pass.js";
+
+declare class OutputPass extends Pass {
+    readonly isOutputPass: true;
+
+    uniforms: Record<string, IUniform>;
+    material: RawShaderMaterial;
 
-export class OutputPass extends Pass {
     constructor();
-    uniforms: object;
-    material: ShaderMaterial;
-    fsQuad: FullScreenQuad;
 }
+
+export { OutputPass };