@types/three 0.178.1 → 0.179.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: Wed, 09 Jul 2025 18:02:54 GMT
+ * Last updated: Mon, 04 Aug 2025 15:38:34 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

@@ -116,7 +116,7 @@ export * from "./loaders/TGALoader.js";
 export * from "./loaders/TIFFLoader.js";
 export * from "./loaders/TTFLoader.js";
 export * from "./loaders/UltraHDRLoader.js";
-export * from "./loaders/USDZLoader.js";
+export * from "./loaders/USDLoader.js";
 export * from "./loaders/VOXLoader.js";
 export * from "./loaders/VRMLLoader.js";
 export * from "./loaders/VTKLoader.js";
@@ -145,7 +145,6 @@ export * from "./misc/MorphAnimMesh.js";
 export * from "./misc/MorphBlendMesh.js";
 export * from "./misc/ProgressiveLightMap.js";
 export * from "./misc/RollerCoaster.js";
-export * from "./misc/Timer.js";
 export * from "./misc/TubePainter.js";
 export * from "./misc/Volume.js";
 export * from "./misc/VolumeSlice.js";

three/examples/jsm/exporters/USDZExporter.d.ts

@@ -5,6 +5,7 @@ import * as WebGPUTextureUtils from "../utils/WebGPUTextureUtils.js";
 export interface USDZExporterOptions {
     ar?: { anchoring: { type: "plane" }; planeAnchoring: { alignment: "horizontal" | "vertical" | "any" } } | undefined;
     includeAnchoringProperties?: boolean | undefined;
+    onlyVisible?: boolean | undefined;
     quickLookCompatible?: boolean | undefined;
     maxTextureSize?: number | undefined;
 }

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

@@ -1,4 +1,14 @@
-import { DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
+import {
+    DataTextureLoader,
+    FloatType,
+    HalfFloatType,
+    LoadingManager,
+    PixelFormat,
+    RedFormat,
+    RGBAFormat,
+    RGFormat,
+    TextureDataType,
+} from "three";
 
 export interface EXR {
     header: object;
@@ -7,13 +17,16 @@ export interface EXR {
     data: Float32Array | Uint16Array;
     format: PixelFormat;
     colorSpace: string;
-    type: TextureDataType;
+    type: typeof HalfFloatType | typeof FloatType;
 }
 
-export class EXRLoader extends DataTextureLoader {
-    constructor(manager?: LoadingManager);
+declare class EXRLoader extends DataTextureLoader {
     type: TextureDataType;
+    outputFormat: typeof RGBAFormat | typeof RGFormat | typeof RedFormat;
+
+    constructor(manager?: LoadingManager);
 
     parse(buffer: ArrayBuffer): EXR;
-    setDataType(type: TextureDataType): this;
+    setDataType(type: typeof HalfFloatType | typeof FloatType): this;
+    setOutputFormat(value: typeof RGBAFormat | typeof RGFormat | typeof RedFormat): this;
 }

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

@@ -0,0 +1,9 @@
+import { Group, Loader, LoadingManager } from "three";
+
+declare class USDLoader extends Loader<Group> {
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: ArrayBuffer | string): Group;
+}
+
+export { USDLoader };

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

@@ -1,11 +1,14 @@
-import { Group, Loader, LoadingManager, Mesh } from "three";
+import { LoadingManager } from "three";
+import { USDLoader } from "./USDLoader.js";
 
-export class USDAParser {
-    parse(text: string): object;
-}
-
-export class USDZLoader extends Loader<Mesh> {
+/**
+ * @deprecated USDZLoader has been deprecated. Please use USDLoader instead.
+ */
+declare class USDZLoader extends USDLoader {
+    /**
+     * @deprecated USDZLoader has been deprecated. Please use USDLoader instead.
+     */
     constructor(manager?: LoadingManager);
-
-    parse(buffer: ArrayBuffer | string): Group;
 }
+
+export { USDZLoader };

three/examples/jsm/tsl/display/TRAANode.d.ts

@@ -0,0 +1,22 @@
+import { ShaderNodeObject } from "three/tsl";
+import { Camera, Node, TempNode, TextureNode } from "three/webgpu";
+
+declare class TRAANode extends TempNode {
+    readonly isTRAANode: true;
+
+    beautyNode: TextureNode;
+    depthNode: TextureNode;
+    velocityNode: TextureNode;
+    camera: Camera;
+
+    constructor(beautyNode: TextureNode, depthNode: TextureNode, velocityNode: TextureNode, camera: Camera);
+}
+
+export default TRAANode;
+
+export const traa: (
+    beautyNode: Node,
+    depthNode: TextureNode,
+    velocityNode: TextureNode,
+    camera: Camera,
+) => ShaderNodeObject<TRAANode>;

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.178.1",
+    "version": "0.179.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -46,9 +46,9 @@
         "@types/webxr": "*",
         "@webgpu/types": "*",
         "fflate": "~0.8.2",
-        "meshoptimizer": "~0.18.1"
+        "meshoptimizer": "~0.22.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "d9c620a2d4d95c3bca7cfc75c9b59be43aedab8c28dfc9871f33870fefadd371",
-    "typeScriptVersion": "5.1"
+    "typesPublisherContentHash": "184261baf6703d118d65b2d005bcc72af9877981f78da02aa9756329a95df8a8",
+    "typeScriptVersion": "5.2"
 }

three/src/Three.Core.d.ts

@@ -39,6 +39,7 @@ export * from "./core/Object3D.js";
 export * from "./core/Raycaster.js";
 export * from "./core/RenderTarget.js";
 export * from "./core/RenderTarget3D.js";
+export * from "./core/Timer.js";
 export * from "./core/Uniform.js";
 export * from "./core/UniformsGroup.js";
 export * from "./extras/Controls.js";

three/src/Three.TSL.d.ts

@@ -2,8 +2,10 @@ import * as TSL from "./nodes/TSL.js";
 
 export const BRDF_GGX: typeof TSL.BRDF_GGX;
 export const BRDF_Lambert: typeof TSL.BRDF_Lambert;
+export const BasicPointShadowFilter: typeof TSL.BasicPointShadowFilter;
 export const BasicShadowFilter: typeof TSL.BasicShadowFilter;
 export const Break: typeof TSL.Break;
+export const Const: typeof TSL.Const;
 export const Continue: typeof TSL.Continue;
 export const DFGApprox: typeof TSL.DFGApprox;
 export const D_GGX: typeof TSL.D_GGX;
@@ -13,27 +15,32 @@ export const F_Schlick: typeof TSL.F_Schlick;
 export const Fn: typeof TSL.Fn;
 export const INFINITY: typeof TSL.INFINITY;
 export const If: typeof TSL.If;
-export const Switch: typeof TSL.Switch;
 export const Loop: typeof TSL.Loop;
+export const NodeAccess: typeof TSL.NodeAccess;
 export const NodeShaderStage: typeof TSL.NodeShaderStage;
 export const NodeType: typeof TSL.NodeType;
 export const NodeUpdateType: typeof TSL.NodeUpdateType;
-export const NodeAccess: typeof TSL.NodeAccess;
 export const PCFShadowFilter: typeof TSL.PCFShadowFilter;
 export const PCFSoftShadowFilter: typeof TSL.PCFSoftShadowFilter;
 export const PI: typeof TSL.PI;
 export const PI2: typeof TSL.PI2;
+export const PointShadowFilter: typeof TSL.PointShadowFilter;
 export const Return: typeof TSL.Return;
 export const Schlick_to_F0: typeof TSL.Schlick_to_F0;
 export const ScriptableNodeResources: typeof TSL.ScriptableNodeResources;
 export const ShaderNode: typeof TSL.ShaderNode;
+export const Stack: typeof TSL.Stack;
+export const Switch: typeof TSL.Switch;
 export const TBNViewMatrix: typeof TSL.TBNViewMatrix;
 export const VSMShadowFilter: typeof TSL.VSMShadowFilter;
 export const V_GGX_SmithCorrelated: typeof TSL.V_GGX_SmithCorrelated;
+export const Var: typeof TSL.Var;
+export const VarIntent: typeof TSL.VarIntent;
 export const abs: typeof TSL.abs;
 export const acesFilmicToneMapping: typeof TSL.acesFilmicToneMapping;
 export const acos: typeof TSL.acos;
 export const add: typeof TSL.add;
+export const addMethodChaining: typeof TSL.addMethodChaining;
 export const addNodeElement: typeof TSL.addNodeElement;
 export const agxToneMapping: typeof TSL.agxToneMapping;
 export const all: typeof TSL.all;
@@ -53,13 +60,13 @@ export const atan2: typeof TSL.atan2;
 export const atomicAdd: typeof TSL.atomicAdd;
 export const atomicAnd: typeof TSL.atomicAnd;
 export const atomicFunc: typeof TSL.atomicFunc;
+export const atomicLoad: typeof TSL.atomicLoad;
 export const atomicMax: typeof TSL.atomicMax;
 export const atomicMin: typeof TSL.atomicMin;
 export const atomicOr: typeof TSL.atomicOr;
 export const atomicStore: typeof TSL.atomicStore;
 export const atomicSub: typeof TSL.atomicSub;
 export const atomicXor: typeof TSL.atomicXor;
-export const atomicLoad: typeof TSL.atomicLoad;
 export const attenuationColor: typeof TSL.attenuationColor;
 export const attenuationDistance: typeof TSL.attenuationDistance;
 export const attribute: typeof TSL.attribute;
@@ -112,14 +119,15 @@ export const checker: typeof TSL.checker;
 export const cineonToneMapping: typeof TSL.cineonToneMapping;
 export const clamp: typeof TSL.clamp;
 export const clearcoat: typeof TSL.clearcoat;
+export const clearcoatNormalView: typeof TSL.clearcoatNormalView;
 export const clearcoatRoughness: typeof TSL.clearcoatRoughness;
 export const code: typeof TSL.code;
 export const color: typeof TSL.color;
 export const colorSpaceToWorking: typeof TSL.colorSpaceToWorking;
 export const colorToDirection: typeof TSL.colorToDirection;
 export const compute: typeof TSL.compute;
+export const computeKernel: typeof TSL.computeKernel;
 export const computeSkinning: typeof TSL.computeSkinning;
-export const Const: typeof TSL.Const;
 export const context: typeof TSL.context;
 export const convert: typeof TSL.convert;
 export const convertColorSpace: typeof TSL.convertColorSpace;
@@ -127,6 +135,8 @@ export const convertToTexture: typeof TSL.convertToTexture;
 export const cos: typeof TSL.cos;
 export const cross: typeof TSL.cross;
 export const cubeTexture: typeof TSL.cubeTexture;
+export const cubeTextureBase: typeof TSL.cubeTextureBase;
+export const cubeToUV: typeof TSL.cubeToUV;
 export const dFdx: typeof TSL.dFdx;
 export const dFdy: typeof TSL.dFdy;
 export const dashSize: typeof TSL.dashSize;
@@ -142,10 +152,12 @@ export const densityFog: typeof TSL.densityFog;
 export const densityFogFactor: typeof TSL.densityFogFactor;
 export const depth: typeof TSL.depth;
 export const depthPass: typeof TSL.depthPass;
+export const determinant: typeof TSL.determinant;
 export const difference: typeof TSL.difference;
 export const diffuseColor: typeof TSL.diffuseColor;
 export const directPointLight: typeof TSL.directPointLight;
 export const directionToColor: typeof TSL.directionToColor;
+export const directionToFaceDirection: typeof TSL.directionToFaceDirection;
 export const dispersion: typeof TSL.dispersion;
 export const distance: typeof TSL.distance;
 export const div: typeof TSL.div;
@@ -184,10 +196,11 @@ export const getParallaxCorrectNormal: typeof TSL.getParallaxCorrectNormal;
 export const getRoughness: typeof TSL.getRoughness;
 export const getScreenPosition: typeof TSL.getScreenPosition;
 export const getShIrradianceAt: typeof TSL.getShIrradianceAt;
-export const getTextureIndex: typeof TSL.getTextureIndex;
-export const getViewPosition: typeof TSL.getViewPosition;
 export const getShadowMaterial: typeof TSL.getShadowMaterial;
 export const getShadowRenderObjectFunction: typeof TSL.getShadowRenderObjectFunction;
+export const getTextureIndex: typeof TSL.getTextureIndex;
+export const getViewPosition: typeof TSL.getViewPosition;
+export const globalId: typeof TSL.globalId;
 export const glsl: typeof TSL.glsl;
 export const glslFn: typeof TSL.glslFn;
 export const grayscale: typeof TSL.grayscale;
@@ -206,6 +219,7 @@ export const instancedBufferAttribute: typeof TSL.instancedBufferAttribute;
 export const instancedDynamicBufferAttribute: typeof TSL.instancedDynamicBufferAttribute;
 export const instancedMesh: typeof TSL.instancedMesh;
 export const int: typeof TSL.int;
+export const inverse: typeof TSL.inverse;
 export const inverseSqrt: typeof TSL.inverseSqrt;
 export const inversesqrt: typeof TSL.inversesqrt;
 export const invocationLocalIndex: typeof TSL.invocationLocalIndex;
@@ -224,6 +238,7 @@ export const lengthSq: typeof TSL.lengthSq;
 export const lessThan: typeof TSL.lessThan;
 export const lessThanEqual: typeof TSL.lessThanEqual;
 export const lightPosition: typeof TSL.lightPosition;
+export const lightProjectionUV: typeof TSL.lightProjectionUV;
 export const lightShadowMatrix: typeof TSL.lightShadowMatrix;
 export const lightTargetDirection: typeof TSL.lightTargetDirection;
 export const lightTargetPosition: typeof TSL.lightTargetPosition;
@@ -233,12 +248,10 @@ export const lights: typeof TSL.lights;
 export const linearDepth: typeof TSL.linearDepth;
 export const linearToneMapping: typeof TSL.linearToneMapping;
 export const localId: typeof TSL.localId;
-export const globalId: typeof TSL.globalId;
 export const log: typeof TSL.log;
 export const log2: typeof TSL.log2;
 export const logarithmicDepthToViewZ: typeof TSL.logarithmicDepthToViewZ;
 export const luminance: typeof TSL.luminance;
-export const mediumpModelViewMatrix: typeof TSL.mediumpModelViewMatrix;
 export const mat2: typeof TSL.mat2;
 export const mat3: typeof TSL.mat3;
 export const mat4: typeof TSL.mat4;
@@ -255,6 +268,8 @@ export const materialClearcoatRoughness: typeof TSL.materialClearcoatRoughness;
 export const materialColor: typeof TSL.materialColor;
 export const materialDispersion: typeof TSL.materialDispersion;
 export const materialEmissive: typeof TSL.materialEmissive;
+export const materialEnvIntensity: typeof TSL.materialEnvIntensity;
+export const materialEnvRotation: typeof TSL.materialEnvRotation;
 export const materialIOR: typeof TSL.materialIOR;
 export const materialIridescence: typeof TSL.materialIridescence;
 export const materialIridescenceIOR: typeof TSL.materialIridescenceIOR;
@@ -285,6 +300,7 @@ export const materialThickness: typeof TSL.materialThickness;
 export const materialTransmission: typeof TSL.materialTransmission;
 export const max: typeof TSL.max;
 export const maxMipLevel: typeof TSL.maxMipLevel;
+export const mediumpModelViewMatrix: typeof TSL.mediumpModelViewMatrix;
 export const metalness: typeof TSL.metalness;
 export const min: typeof TSL.min;
 export const mix: typeof TSL.mix;
@@ -305,24 +321,45 @@ export const morphReference: typeof TSL.morphReference;
 export const mrt: typeof TSL.mrt;
 export const mul: typeof TSL.mul;
 export const mx_aastep: typeof TSL.mx_aastep;
+export const mx_add: typeof TSL.mx_add;
+export const mx_atan2: typeof TSL.mx_atan2;
 export const mx_cell_noise_float: typeof TSL.mx_cell_noise_float;
 export const mx_contrast: typeof TSL.mx_contrast;
+export const mx_divide: typeof TSL.mx_divide;
 export const mx_fractal_noise_float: typeof TSL.mx_fractal_noise_float;
 export const mx_fractal_noise_vec2: typeof TSL.mx_fractal_noise_vec2;
 export const mx_fractal_noise_vec3: typeof TSL.mx_fractal_noise_vec3;
 export const mx_fractal_noise_vec4: typeof TSL.mx_fractal_noise_vec4;
+export const mx_frame: typeof TSL.mx_frame;
+export const mx_heighttonormal: typeof TSL.mx_heighttonormal;
 export const mx_hsvtorgb: typeof TSL.mx_hsvtorgb;
+export const mx_ifequal: typeof TSL.mx_ifequal;
+export const mx_ifgreater: typeof TSL.mx_ifgreater;
+export const mx_ifgreatereq: typeof TSL.mx_ifgreatereq;
+export const mx_invert: typeof TSL.mx_invert;
+export const mx_modulo: typeof TSL.mx_modulo;
+export const mx_multiply: typeof TSL.mx_multiply;
 export const mx_noise_float: typeof TSL.mx_noise_float;
 export const mx_noise_vec3: typeof TSL.mx_noise_vec3;
 export const mx_noise_vec4: typeof TSL.mx_noise_vec4;
+export const mx_place2d: typeof TSL.mx_place2d;
+export const mx_power: typeof TSL.mx_power;
+export const mx_ramp4: typeof TSL.mx_ramp4;
 export const mx_ramplr: typeof TSL.mx_ramplr;
 export const mx_ramptb: typeof TSL.mx_ramptb;
 export const mx_rgbtohsv: typeof TSL.mx_rgbtohsv;
+export const mx_rotate2d: typeof TSL.mx_rotate2d;
+export const mx_rotate3d: typeof TSL.mx_rotate3d;
 export const mx_safepower: typeof TSL.mx_safepower;
+export const mx_separate: typeof TSL.mx_separate;
 export const mx_splitlr: typeof TSL.mx_splitlr;
 export const mx_splittb: typeof TSL.mx_splittb;
 export const mx_srgb_texture_to_lin_rec709: typeof TSL.mx_srgb_texture_to_lin_rec709;
+export const mx_subtract: typeof TSL.mx_subtract;
+export const mx_timer: typeof TSL.mx_timer;
 export const mx_transform_uv: typeof TSL.mx_transform_uv;
+export const mx_unifiednoise2d: typeof TSL.mx_unifiednoise2d;
+export const mx_unifiednoise3d: typeof TSL.mx_unifiednoise3d;
 export const mx_worley_noise_float: typeof TSL.mx_worley_noise_float;
 export const mx_worley_noise_vec2: typeof TSL.mx_worley_noise_vec2;
 export const mx_worley_noise_vec3: typeof TSL.mx_worley_noise_vec3;
@@ -331,8 +368,10 @@ export const neutralToneMapping: typeof TSL.neutralToneMapping;
 export const nodeArray: typeof TSL.nodeArray;
 export const nodeImmutable: typeof TSL.nodeImmutable;
 export const nodeObject: typeof TSL.nodeObject;
+export const nodeObjectIntent: typeof TSL.nodeObjectIntent;
 export const nodeObjects: typeof TSL.nodeObjects;
 export const nodeProxy: typeof TSL.nodeProxy;
+export const nodeProxyIntent: typeof TSL.nodeProxyIntent;
 export const normalFlat: typeof TSL.normalFlat;
 export const normalGeometry: typeof TSL.normalGeometry;
 export const normalLocal: typeof TSL.normalLocal;
@@ -352,6 +391,8 @@ export const objectRadius: typeof TSL.objectRadius;
 export const objectScale: typeof TSL.objectScale;
 export const objectViewPosition: typeof TSL.objectViewPosition;
 export const objectWorldMatrix: typeof TSL.objectWorldMatrix;
+export const OnObjectUpdate: typeof TSL.OnObjectUpdate;
+export const OnMaterialUpdate: typeof TSL.OnMaterialUpdate;
 export const oneMinus: typeof TSL.oneMinus;
 export const or: typeof TSL.or;
 export const orthographicDepthToViewZ: typeof TSL.orthographicDepthToViewZ;
@@ -372,6 +413,7 @@ export const passTexture: typeof TSL.passTexture;
 export const pcurve: typeof TSL.pcurve;
 export const perspectiveDepthToViewZ: typeof TSL.perspectiveDepthToViewZ;
 export const pmremTexture: typeof TSL.pmremTexture;
+export const pointShadow: typeof TSL.pointShadow;
 export const pointUV: typeof TSL.pointUV;
 export const pointWidth: typeof TSL.pointWidth;
 export const positionGeometry: typeof TSL.positionGeometry;
@@ -394,7 +436,6 @@ export const range: typeof TSL.range;
 export const rangeFog: typeof TSL.rangeFog;
 export const rangeFogFactor: typeof TSL.rangeFogFactor;
 export const reciprocal: typeof TSL.reciprocal;
-export const lightProjectionUV: typeof TSL.lightProjectionUV;
 export const reference: typeof TSL.reference;
 export const referenceBuffer: typeof TSL.referenceBuffer;
 export const reflect: typeof TSL.reflect;
@@ -430,12 +471,12 @@ export const scriptable: typeof TSL.scriptable;
 export const scriptableValue: typeof TSL.scriptableValue;
 export const select: typeof TSL.select;
 export const setCurrentStack: typeof TSL.setCurrentStack;
+export const setName: typeof TSL.setName;
 export const shaderStages: typeof TSL.shaderStages;
 export const shadow: typeof TSL.shadow;
-export const pointShadow: typeof TSL.pointShadow;
 export const shadowPositionWorld: typeof TSL.shadowPositionWorld;
-export const sharedUniformGroup: typeof TSL.sharedUniformGroup;
 export const shapeCircle: typeof TSL.shapeCircle;
+export const sharedUniformGroup: typeof TSL.sharedUniformGroup;
 export const sheen: typeof TSL.sheen;
 export const sheenRoughness: typeof TSL.sheenRoughness;
 export const shiftLeft: typeof TSL.shiftLeft;
@@ -455,6 +496,7 @@ export const spritesheetUV: typeof TSL.spritesheetUV;
 export const sqrt: typeof TSL.sqrt;
 export const stack: typeof TSL.stack;
 export const step: typeof TSL.step;
+export const stepElement: typeof TSL.stepElement;
 export const storage: typeof TSL.storage;
 export const storageBarrier: typeof TSL.storageBarrier;
 export const storageObject: typeof TSL.storageObject;
@@ -502,8 +544,8 @@ export const triplanarTextures: typeof TSL.triplanarTextures;
 export const trunc: typeof TSL.trunc;
 export const uint: typeof TSL.uint;
 export const uniform: typeof TSL.uniform;
-export const uniformCubeTexture: typeof TSL.uniformCubeTexture;
 export const uniformArray: typeof TSL.uniformArray;
+export const uniformCubeTexture: typeof TSL.uniformCubeTexture;
 export const uniformGroup: typeof TSL.uniformGroup;
 export const uniformTexture: typeof TSL.uniformTexture;
 export const unpremultiplyAlpha: typeof TSL.unpremultiplyAlpha;
@@ -512,7 +554,6 @@ export const uv: typeof TSL.uv;
 export const uvec2: typeof TSL.uvec2;
 export const uvec3: typeof TSL.uvec3;
 export const uvec4: typeof TSL.uvec4;
-export const Var: typeof TSL.Var;
 export const varying: typeof TSL.varying;
 export const varyingProperty: typeof TSL.varyingProperty;
 export const vec2: typeof TSL.vec2;
@@ -522,6 +563,7 @@ export const vectorComponents: typeof TSL.vectorComponents;
 export const velocity: typeof TSL.velocity;
 export const vertexColor: typeof TSL.vertexColor;
 export const vertexIndex: typeof TSL.vertexIndex;
+export const vertexStage: typeof TSL.vertexStage;
 export const vibrance: typeof TSL.vibrance;
 export const viewZToLogarithmicDepth: typeof TSL.viewZToLogarithmicDepth;
 export const viewZToOrthographicDepth: typeof TSL.viewZToOrthographicDepth;

three/src/animation/KeyframeTrack.d.ts

@@ -31,10 +31,15 @@ export class KeyframeTrack {
      *
      * @param {string} name - The keyframe track's name.
      * @param {Array<number>} times - A list of keyframe times.
-     * @param {Array<number>} values - A list of keyframe values.
+     * @param {Array<number|string|boolean>} values - A list of keyframe values.
      * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
      */
-    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>, interpolation?: InterpolationModes);
+    constructor(
+        name: string,
+        times: ArrayLike<number>,
+        values: ArrayLike<number | string | boolean>,
+        interpolation?: InterpolationModes,
+    );
     /**
      * The track's name can refer to morph targets or bones or
      * possibly other values within an animated object. See {@link PropertyBinding#parseTrackName}

three/src/animation/tracks/BooleanKeyframeTrack.d.ts

@@ -12,7 +12,7 @@ export class BooleanKeyframeTrack extends KeyframeTrack {
      *
      * @param {string} name - The keyframe track's name.
      * @param {Array<number>} times - A list of keyframe times.
-     * @param {Array<number>} values - A list of keyframe values.
+     * @param {Array<boolean>} values - A list of keyframe values.
      */
-    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<boolean>);
 }

three/src/animation/tracks/StringKeyframeTrack.d.ts

@@ -12,7 +12,7 @@ export class StringKeyframeTrack extends KeyframeTrack {
      *
      * @param {string} name - The keyframe track's name.
      * @param {Array<number>} times - A list of keyframe times.
-     * @param {Array<number>} values - A list of keyframe values.
+     * @param {Array<string>} values - A list of keyframe values.
      */
-    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<string>);
 }

three/src/cameras/Camera.d.ts

@@ -13,14 +13,6 @@ import { Vector4 } from "../math/Vector4.js";
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/cameras/Camera.js | Source}
  */
 export class Camera extends Object3D {
-    /**
-     * @remarks
-     * Note that this class is not intended to be called directly; you probably want a
-     * {@link PerspectiveCamera | PerspectiveCamera} or
-     * {@link OrthographicCamera | OrthographicCamera} instead.
-     */
-    constructor();
-
     /**
      * Read-only flag to check if a given object is of type {@link Camera}.
      * @remarks This is a _constant_ value
@@ -65,6 +57,21 @@ export class Camera extends Object3D {
 
     viewport?: Vector4;
 
+    /**
+     * @remarks
+     * Note that this class is not intended to be called directly; you probably want a
+     * {@link PerspectiveCamera | PerspectiveCamera} or
+     * {@link OrthographicCamera | OrthographicCamera} instead.
+     */
+    constructor();
+
+    /**
+     * The flag that indicates whether the camera uses a reversed depth buffer.
+     *
+     * @default false
+     */
+    get reversedDepth(): boolean;
+
     /**
      * Returns a {@link Vector3 | Vector3} representing the world space direction in which the {@link Camera} is looking.
      * @remarks Note: A {@link Camera} looks down its local, negative z-axis.

three/src/constants.d.ts

@@ -774,7 +774,9 @@ export type GLSLVersion = typeof GLSL1 | typeof GLSL3;
 
 export const WebGLCoordinateSystem: 2000;
 export const WebGPUCoordinateSystem: 2001;
-export type CoordinateSystem = typeof WebGLCoordinateSystem | typeof WebGPUCoordinateSystem;
+export type CoordinateSystem =
+    | typeof WebGLCoordinateSystem
+    | typeof WebGPUCoordinateSystem;
 
 export const TimestampQuery: {
     COMPUTE: "compute";

three/{examples/jsm/misc → src/core}/Timer.d.ts

@@ -21,7 +21,7 @@
  *
  * @see https://threejs.org/examples/#webgl_morphtargets_sphere
  */
-export class Timer {
+declare class Timer {
     constructor();
 
     /**
@@ -69,23 +69,9 @@ export class Timer {
      * Updates the internal state of the timer. This method should be called once per simulation step and before you
      * perform queries against the timer (e.g. via {@link getDelta()}).
      *
-     * @param timescale (optional) The current time in milliseconds. Can be obtained from the {@link https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame | requestAnimationFrame} callback argument. If not provided, the current time will be determined with {@link https://developer.mozilla.org/en-US/docs/Web/API/Performance/now | performance.now}.
+     * @param timestamp The current time in milliseconds. Can be obtained from the {@link https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame | requestAnimationFrame} callback argument. If not provided, the current time will be determined with {@link https://developer.mozilla.org/en-US/docs/Web/API/Performance/now | performance.now}.
      */
     update(timestamp?: number): this;
 }
 
-/**
- * A timer that uses a fixed delta.
- */
-export class FixedTimer extends Timer {
-    /**
-     * @param fps The desired fixed delta expressed in frames per second.
-     */
-    constructor(fps?: number);
-
-    /**
-     * Updates the internal state of the timer. This method should be called once per simulation step and before you
-     * perform queries against the timer (e.g. via {@link getDelta()}).
-     */
-    override update(): this;
-}
+export { Timer };

three/src/helpers/SkeletonHelper.d.ts

@@ -1,4 +1,5 @@
 import { Object3D } from "../core/Object3D.js";
+import { Color } from "../math/Color.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Bone } from "../objects/Bone.js";
 import { LineSegments } from "../objects/LineSegments.js";
@@ -19,7 +20,7 @@ import { SkinnedMesh } from "../objects/SkinnedMesh.js";
  * @see {@link https://threejs.org/docs/index.html#api/en/helpers/SkeletonHelper | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/helpers/SkeletonHelper.js | Source}
  */
-export class SkeletonHelper extends LineSegments {
+declare class SkeletonHelper extends LineSegments {
     /**
      * Create a new instance of {@link SkeletonHelper}
      * @param object Usually an instance of {@link THREE.SkinnedMesh | SkinnedMesh}.
@@ -42,20 +43,15 @@ export class SkeletonHelper extends LineSegments {
      */
     override readonly type: string | "SkeletonHelper";
 
-    /**
-     * The list of bones that the helper renders as {@link Line | Lines}.
-     */
-    bones: Bone[];
-
     /**
      * The object passed in the constructor.
      */
     root: SkinnedMesh | Object3D;
 
     /**
-     * Reference to the {@link THREE.Object3D.matrixWorld | root.matrixWorld}.
+     * The list of bones that the helper renders as {@link Line | Lines}.
      */
-    matrix: Matrix4;
+    bones: Bone[];
 
     /**
      * Is set to `false`, as the helper is using the {@link THREE.Object3D.matrixWorld | root.matrixWorld}.
@@ -64,10 +60,7 @@ export class SkeletonHelper extends LineSegments {
      */
     override matrixAutoUpdate: boolean;
 
-    /**
-     * Updates the helper.
-     */
-    update(): void;
+    setColors(color1: Color, color2: Color): this;
 
     /**
      * Frees the GPU-related resources allocated by this instance
@@ -76,3 +69,5 @@ export class SkeletonHelper extends LineSegments {
      */
     dispose(): void;
 }
+
+export { SkeletonHelper };

three/src/loaders/FileLoader.d.ts

@@ -14,6 +14,6 @@ export class FileLoader extends Loader<string | ArrayBuffer> {
     mimeType: string;
     responseType: string;
 
-    setMimeType(mimeType: string): FileLoader;
-    setResponseType(responseType: string): FileLoader;
+    setResponseType(value: string): this;
+    setMimeType(value: string): this;
 }