@types/three 0.178.1 → 0.180.0

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.178.1",
+    "version": "0.180.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": "b06ef6e25296a342a8cb4449c825b5786ae345270e744fa27908d1cb8d51f547",
+    "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";
@@ -153,6 +154,7 @@ export * from "./textures/Data3DTexture.js";
 export * from "./textures/DataArrayTexture.js";
 export * from "./textures/DataTexture.js";
 export * from "./textures/DepthTexture.js";
+export * from "./textures/ExternalTexture.js";
 export * from "./textures/FramebufferTexture.js";
 export * from "./textures/Source.js";
 export * from "./textures/Texture.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;
@@ -90,6 +97,7 @@ export const buffer: typeof TSL.buffer;
 export const bufferAttribute: typeof TSL.bufferAttribute;
 export const bumpMap: typeof TSL.bumpMap;
 export const burn: typeof TSL.burn;
+export const builtin: typeof TSL.builtin;
 export const bvec2: typeof TSL.bvec2;
 export const bvec3: typeof TSL.bvec3;
 export const bvec4: typeof TSL.bvec4;
@@ -104,6 +112,7 @@ export const cameraPosition: typeof TSL.cameraPosition;
 export const cameraProjectionMatrix: typeof TSL.cameraProjectionMatrix;
 export const cameraProjectionMatrixInverse: typeof TSL.cameraProjectionMatrixInverse;
 export const cameraViewMatrix: typeof TSL.cameraViewMatrix;
+export const cameraViewport: typeof TSL.cameraViewport;
 export const cameraWorldMatrix: typeof TSL.cameraWorldMatrix;
 export const cbrt: typeof TSL.cbrt;
 export const cdl: typeof TSL.cdl;
@@ -112,14 +121,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 +137,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 +154,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;
@@ -165,6 +179,8 @@ export const faceDirection: typeof TSL.faceDirection;
 export const faceForward: typeof TSL.faceForward;
 export const faceforward: typeof TSL.faceforward;
 export const float: typeof TSL.float;
+export const floatBitsToInt: typeof TSL.floatBitsToInt;
+export const floatBitsToUint: typeof TSL.floatBitsToUint;
 export const floor: typeof TSL.floor;
 export const fog: typeof TSL.fog;
 export const fract: typeof TSL.fract;
@@ -184,10 +200,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 +223,8 @@ 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 intBitsToFloat: typeof TSL.intBitsToFloat;
+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 +243,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 +253,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 +273,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 +305,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 +326,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 +373,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 +396,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 +418,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 +441,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;
@@ -424,18 +470,19 @@ export const saturate: typeof TSL.saturate;
 export const saturation: typeof TSL.saturation;
 export const screen: typeof TSL.screen;
 export const screenCoordinate: typeof TSL.screenCoordinate;
+export const screenDPR: typeof TSL.screenDPR;
 export const screenSize: typeof TSL.screenSize;
 export const screenUV: typeof TSL.screenUV;
 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 +502,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;
@@ -462,15 +510,35 @@ export const storageTexture: typeof TSL.storageTexture;
 export const string: typeof TSL.string;
 export const struct: typeof TSL.struct;
 export const sub: typeof TSL.sub;
+export const subgroupAdd: typeof TSL.subgroupAdd;
+export const subgroupAll: typeof TSL.subgroupAll;
+export const subgroupAnd: typeof TSL.subgroupAnd;
+export const subgroupAny: typeof TSL.subgroupAny;
+export const subgroupBallot: typeof TSL.subgroupBallot;
+export const subgroupBroadcast: typeof TSL.subgroupBroadcast;
+export const subgroupBroadcastFirst: typeof TSL.subgroupBroadcastFirst;
 export const subBuild: typeof TSL.subBuild;
+export const subgroupElect: typeof TSL.subgroupElect;
+export const subgroupExclusiveAdd: typeof TSL.subgroupExclusiveAdd;
+export const subgroupExclusiveMul: typeof TSL.subgroupExclusiveMul;
+export const subgroupInclusiveAdd: typeof TSL.subgroupInclusiveAdd;
+export const subgroupInclusiveMul: typeof TSL.subgroupInclusiveMul;
 export const subgroupIndex: typeof TSL.subgroupIndex;
+export const subgroupMax: typeof TSL.subgroupMax;
+export const subgroupMin: typeof TSL.subgroupMin;
+export const subgroupMul: typeof TSL.subgroupMul;
+export const subgroupOr: typeof TSL.subgroupOr;
+export const subgroupShuffle: typeof TSL.subgroupShuffle;
+export const subgroupShuffleDown: typeof TSL.subgroupShuffleDown;
+export const subgroupShuffleUp: typeof TSL.subgroupShuffleUp;
+export const subgroupShuffleXor: typeof TSL.subgroupShuffleXor;
 export const subgroupSize: typeof TSL.subgroupSize;
+export const subgroupXor: typeof TSL.subgroupXor;
 export const tan: typeof TSL.tan;
 export const tangentGeometry: typeof TSL.tangentGeometry;
 export const tangentLocal: typeof TSL.tangentLocal;
 export const tangentView: typeof TSL.tangentView;
 export const tangentWorld: typeof TSL.tangentWorld;
-export const temp: typeof TSL.temp;
 export const texture: typeof TSL.texture;
 export const texture3D: typeof TSL.texture3D;
 export const textureBarrier: typeof TSL.textureBarrier;
@@ -482,9 +550,6 @@ export const textureSize: typeof TSL.textureSize;
 export const textureStore: typeof TSL.textureStore;
 export const thickness: typeof TSL.thickness;
 export const time: typeof TSL.time;
-export const timerDelta: typeof TSL.timerDelta;
-export const timerGlobal: typeof TSL.timerGlobal;
-export const timerLocal: typeof TSL.timerLocal;
 export const toneMapping: typeof TSL.toneMapping;
 export const toneMappingExposure: typeof TSL.toneMappingExposure;
 export const toonOutlinePass: typeof TSL.toonOutlinePass;
@@ -501,10 +566,12 @@ export const triplanarTexture: typeof TSL.triplanarTexture;
 export const triplanarTextures: typeof TSL.triplanarTextures;
 export const trunc: typeof TSL.trunc;
 export const uint: typeof TSL.uint;
+export const uintBitsToFloat: typeof TSL.uintBitsToFloat;
 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 uniformFlow: typeof TSL.uniformFlow;
 export const uniformTexture: typeof TSL.uniformTexture;
 export const unpremultiplyAlpha: typeof TSL.unpremultiplyAlpha;
 export const userData: typeof TSL.userData;
@@ -512,7 +579,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 +588,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/AnimationClip.d.ts

@@ -132,6 +132,11 @@ export class AnimationClip {
      * The UUID of the animation clip.
      */
     readonly uuid: string;
+    /**
+     * An object that can be used to store custom data about the animation clip.
+     * It should not hold references to functions as these will not be cloned.
+     */
+    userData: Record<string, unknown>;
     /**
      * Sets the duration of this clip to the duration of its longest keyframe track.
      *

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

@@ -337,6 +337,7 @@ export const UnsignedShort4444Type: 1017;
 export const UnsignedShort5551Type: 1018;
 export const UnsignedInt248Type: 1020;
 export const UnsignedInt5999Type: 35902;
+export const UnsignedInt101111Type: 35899;
 
 export type AttributeGPUType = typeof FloatType | typeof IntType;
 
@@ -358,7 +359,8 @@ export type TextureDataType =
     | typeof UnsignedShort4444Type
     | typeof UnsignedShort5551Type
     | typeof UnsignedInt248Type
-    | typeof UnsignedInt5999Type;
+    | typeof UnsignedInt5999Type
+    | typeof UnsignedInt101111Type;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Pixel formats
@@ -774,7 +776,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;
 }

three/src/loaders/ImageBitmapLoader.d.ts

@@ -2,21 +2,21 @@ import { Loader } from "./Loader.js";
 import { LoadingManager } from "./LoadingManager.js";
 
 export class ImageBitmapLoader extends Loader<ImageBitmap> {
+    readonly isImageBitmapLoader: true;
+
+    /**
+     * @default { premultiplyAlpha: 'none' }
+     */
+    options: ImageBitmapOptions;
+
     constructor(manager?: LoadingManager);
 
+    setOptions(options: ImageBitmapOptions): this;
+
     load(
         url: string,
         onLoad?: (data: ImageBitmap) => void,
         onProgress?: (event: ProgressEvent) => void,
         onError?: (err: unknown) => void,
     ): void;
-
-    /**
-     * @default { premultiplyAlpha: 'none' }
-     */
-    options: undefined | object;
-
-    readonly isImageBitmapLoader: true;
-
-    setOptions(options: object): ImageBitmapLoader;
 }

three/src/loaders/Loader.d.ts

@@ -45,6 +45,7 @@ export class Loader<TData = unknown, TUrl = string> {
     setPath(path: string): this;
     setResourcePath(resourcePath: string): this;
     setRequestHeader(requestHeader: { [header: string]: string }): this;
+    abort(): this;
 
     static DEFAULT_MATERIAL_NAME: string;
 }