@types/three 0.182.0 → 0.183.1

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

@@ -1,4 +1,4 @@
-import { Node, TempNode, TextureNode, UniformNode, Vector3 } from "three/webgpu";
+import { Node, TempNode, TextureNode } from "three/webgpu";
 
 interface LensflareNodeParams {
     ghostTint?: Node | undefined;
@@ -12,11 +12,11 @@ interface LensflareNodeParams {
 declare class LensflareNode extends TempNode {
     textureNode: TextureNode;
 
-    ghostTintNode: UniformNode<Vector3>;
-    thresholdNode: UniformNode<number>;
-    ghostSamplesNode: UniformNode<number>;
-    ghostSpacingNode: UniformNode<number>;
-    ghostAttenuationFactorNode: UniformNode<number>;
+    ghostTintNode: Node<"vec3">;
+    thresholdNode: Node<"float">;
+    ghostSamplesNode: Node<"float">;
+    ghostSpacingNode: Node<"float">;
+    ghostAttenuationFactorNode: Node<"float">;
     downSampleRatio: number;
 
     constructor(textureNode: TextureNode, params?: LensflareNodeParams);

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

@@ -1,12 +1,12 @@
-import { Data3DTexture, Node, TempNode, Texture3DNode, UniformNode } from "three/webgpu";
+import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class Lut3DNode extends TempNode {
     inputNode: Node;
-    lutNode: Texture3DNode;
-    size: UniformNode<number>;
-    intensityNode: UniformNode<number>;
+    lutNode: TextureNode;
+    size: UniformNode<"float", number>;
+    intensityNode: Node<"float">;
 
-    constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
+    constructor(inputNode: Node, lutNode: TextureNode, size: number, intensityNode: Node);
 }
 
 export default Lut3DNode;

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

@@ -4,4 +4,4 @@ export const motionBlur: (
     inputNode: Node,
     velocity: Node,
     numSamples?: Node,
-) => Node;
+) => Node<"vec4">;

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

@@ -1,4 +1,4 @@
-import { Camera, Node, Object3D, Scene, TempNode, TextureNode, UniformNode } from "three/webgpu";
+import { Camera, Node, Object3D, Scene, TempNode, TextureNode } from "three/webgpu";
 
 export interface OutlineNodeParams {
     selectedObjects?: Object3D[] | undefined;
@@ -7,19 +7,19 @@ export interface OutlineNodeParams {
     downSampleRatio?: number | undefined;
 }
 
-declare class OutlineNode extends TempNode {
+declare class OutlineNode extends TempNode<"vec4"> {
     scene: Scene;
     camera: Camera;
     selectedObjects: Object3D[];
-    edgeThicknessNode: UniformNode<number>;
-    edgeGlowNode: UniformNode<number>;
+    edgeThicknessNode: Node<"float">;
+    edgeGlowNode: Node<"float">;
     downSampleRatio: number;
 
     constructor(scene: Scene, camera: Camera, params?: OutlineNodeParams);
 
-    get visibleEdge(): Node;
+    get visibleEdge(): Node<"float">;
 
-    get hiddenEdge(): Node;
+    get hiddenEdge(): Node<"float">;
 
     getTextureNode(): TextureNode;
 

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

@@ -1,27 +1,27 @@
-import { Camera, PassNode, Scene, UniformNode } from "three/webgpu";
+import { Camera, Node, PassNode, Scene } from "three/webgpu";
 
 declare class PixelationPassNode extends PassNode {
-    pixelSize: UniformNode<number>;
-    normalEdgeStrength: UniformNode<number>;
-    depthEdgeStrength: UniformNode<number>;
+    pixelSize: Node<"float">;
+    normalEdgeStrength: Node<"float">;
+    depthEdgeStrength: Node<"float">;
 
     readonly isPixelationPassNode: true;
 
     constructor(
         scene: Scene,
         camera: Camera,
-        pixelSize: number,
-        normalEdgeStrength: number,
-        depthEdgeStrength: number,
+        pixelSize: Node,
+        normalEdgeStrength: Node,
+        depthEdgeStrength: Node,
     );
 }
 
 export const pixelationPass: (
     scene: Scene,
     camera: Camera,
-    pixelSize: UniformNode<number>,
-    normalEdgeStrength: UniformNode<number>,
-    depthEdgeStrength: UniformNode<number>,
+    pixelSize: Node | number,
+    normalEdgeStrength: Node | number,
+    depthEdgeStrength: Node | number,
 ) => PixelationPassNode;
 
 export default PixelationPassNode;

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

@@ -2,8 +2,8 @@ import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 export default class RGBShiftNode extends TempNode {
     textureNode: TextureNode;
-    amount: UniformNode<number>;
-    angle: UniformNode<number>;
+    amount: UniformNode<"float", number>;
+    angle: UniformNode<"float", number>;
 
     constructor(textureNode: TextureNode, amount?: number, angle?: number);
 

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

@@ -0,0 +1,17 @@
+import { Camera, Node, PassNode, Scene } from "three/webgpu";
+
+export interface RetroPassNodeOptions {
+    affineDistortion?: Node | null | undefined;
+    filterTextures?: boolean | undefined;
+}
+
+declare class RetroPassNode extends PassNode {
+    affineDistortionNode: Node | null;
+    filterTextures: boolean;
+
+    constructor(scene: Scene, camera: Camera, options?: RetroPassNodeOptions);
+}
+
+export default RetroPassNode;
+
+export const retroPass: (scene: Scene, camera: Camera, options?: RetroPassNodeOptions) => RetroPassNode;

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

@@ -8,7 +8,7 @@ declare class SSAAPassNode extends PassNode {
     clearColor: Color;
     clearAlpha: number;
 
-    sampleWeight: UniformNode<number>;
+    sampleWeight: UniformNode<"float", number>;
 
     sampleRenderTarget: RenderTarget | null;
 

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

@@ -1,20 +1,20 @@
 import { Node, PerspectiveCamera, TempNode, UniformNode } from "three/webgpu";
 
-declare class SSGINode extends TempNode {
+declare class SSGINode extends TempNode<"vec4"> {
     beautyNode: Node;
     depthNode: Node;
     normalNode: Node;
 
-    sliceCount: UniformNode<number>;
-    stepCount: UniformNode<number>;
-    aoIntensity: UniformNode<number>;
-    giIntensity: UniformNode<number>;
-    radius: UniformNode<number>;
-    useScreenSpaceSampling: UniformNode<boolean>;
-    expFactor: UniformNode<number>;
-    thickness: UniformNode<number>;
-    useLinearThickness: UniformNode<boolean>;
-    backfaceLighting: UniformNode<number>;
+    sliceCount: UniformNode<"uint", number>;
+    stepCount: UniformNode<"uint", number>;
+    aoIntensity: UniformNode<"float", number>;
+    giIntensity: UniformNode<"float", number>;
+    radius: UniformNode<"float", number>;
+    useScreenSpaceSampling: UniformNode<"bool", boolean>;
+    expFactor: UniformNode<"float", number>;
+    thickness: UniformNode<"float", number>;
+    useLinearThickness: UniformNode<"bool", boolean>;
+    backfaceLighting: UniformNode<"float", number>;
     useTemporalFiltering: boolean;
 
     constructor(beautyNode: Node, depthNode: Node, normalNode: Node, camera: PerspectiveCamera);

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

@@ -1,6 +1,6 @@
 import { Camera, Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
-declare class SSRNode extends TempNode {
+declare class SSRNode extends TempNode<"vec4"> {
     colorNode: Node;
     depthNode: Node;
     normalNode: Node;
@@ -10,11 +10,11 @@ declare class SSRNode extends TempNode {
 
     resolutionScale: number;
 
-    maxDistance: UniformNode<number>;
-    thickness: UniformNode<number>;
-    opacity: UniformNode<number>;
-    quality: UniformNode<number>;
-    blurQuality: UniformNode<number>;
+    maxDistance: UniformNode<"float", number>;
+    thickness: UniformNode<"float", number>;
+    opacity: UniformNode<"float", number>;
+    quality: UniformNode<"float", number>;
+    blurQuality: UniformNode<"float", number>;
 
     constructor(
         colorNode: Node,

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

@@ -1,12 +1,12 @@
 import { Camera, DirectionalLight, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
-declare class SSSNode extends TempNode {
+declare class SSSNode extends TempNode<"float"> {
     depthNode: TextureNode;
 
-    maxDistance: UniformNode<number>;
-    thickness: UniformNode<number>;
-    shadowIntensity: UniformNode<number>;
-    quality: UniformNode<number>;
+    maxDistance: UniformNode<"float", number>;
+    thickness: UniformNode<"float", number>;
+    shadowIntensity: UniformNode<"float", number>;
+    quality: UniformNode<"float", number>;
     resolutionScale: number;
     useTemporalFiltering: boolean;
 

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

@@ -0,0 +1,3 @@
+import { Node } from "three/webgpu";
+
+export const circle: (scale?: Node<"float">, softness?: Node<"float"> | number, coord?: Node<"vec2">) => Node<"float">;

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

@@ -25,7 +25,7 @@ export const transition: (
     node: Node,
     nodeB: Node,
     mixTexture: Node,
-    mixRatio: UniformNode<number>,
-    threshold: UniformNode<number>,
-    useTexture: UniformNode<number>,
+    mixRatio: Node | number,
+    threshold: Node | number,
+    useTexture: Node | number,
 ) => TransitionNode;

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

@@ -7,4 +7,4 @@ export interface BoxBlurOptions {
     premultipliedAlpha?: boolean | undefined;
 }
 
-export const boxBlur: (textureNode: Node, options?: BoxBlurOptions) => Node;
+export const boxBlur: (textureNode: Node, options?: BoxBlurOptions) => Node<"vec4">;

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

@@ -0,0 +1,15 @@
+import { Camera, Color, Node } from "three/webgpu";
+
+export interface DepthAwareBlendOptions {
+    blendColor?: Node | Color;
+    edgeRadius?: Node<"int"> | number;
+    edgeStrength?: Node<"float"> | number;
+}
+
+export const depthAwareBlend: (
+    baseNode: Node,
+    blendNode: Node,
+    depthNode: Node,
+    camera: Camera,
+    options?: DepthAwareBlendOptions,
+) => Node<"vec4">;

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

@@ -10,4 +10,4 @@ export const hashBlur: (
     textureNode: Node,
     bluramount?: Node | number,
     options?: HashBlurOptions,
-) => Node;
+) => Node<"vec4">;

three/examples/jsm/tsl/math/Bayer.d.ts

@@ -1,3 +1,5 @@
 import { Node } from "three/webgpu";
 
 export const bayer16: (uv: Node) => Node;
+
+export const bayerDither: (color: Node<"vec3">, steps?: Node<"float">) => Node<"vec3">;

three/examples/jsm/tsl/utils/Raymarching.d.ts

@@ -3,6 +3,6 @@ import { FunctionNode, Node } from "three/webgpu";
 export const RaymarchingBox: (
     steps: number | Node,
     callback:
-        | ((params: { positionRay: Node }) => void)
-        | FunctionNode<{ positionRay: Node }>,
+        | ((params: { positionRay: Node<"vec3"> }) => void)
+        | FunctionNode<{ positionRay: Node<"vec3"> }>,
 ) => void;

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.182.0",
+    "version": "0.183.1",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -46,9 +46,9 @@
         "@types/webxr": ">=0.5.17",
         "@webgpu/types": "*",
         "fflate": "~0.8.2",
-        "meshoptimizer": "~0.22.0"
+        "meshoptimizer": "~1.0.1"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "f3281b335e326a31ecce951778649efebdd62165c3fa47922257c4a8aebf0fa4",
+    "typesPublisherContentHash": "468e3745918d138cd544eeb6d2918750f9ada85b28e98751fe1bca8bc9875fa9",
     "typeScriptVersion": "5.2"
 }

three/src/Three.Core.d.ts

@@ -105,6 +105,7 @@ export * from "./math/Euler.js";
 export * from "./math/Frustum.js";
 export * from "./math/FrustumArray.js";
 export * from "./math/Interpolant.js";
+export * from "./math/interpolants/BezierInterpolant.js";
 export * from "./math/interpolants/CubicInterpolant.js";
 export * from "./math/interpolants/DiscreteInterpolant.js";
 export * from "./math/interpolants/LinearInterpolant.js";
@@ -139,7 +140,6 @@ export * from "./objects/SkinnedMesh.js";
 export * from "./objects/Sprite.js";
 export * from "./renderers/WebGL3DRenderTarget.js";
 export * from "./renderers/WebGLArrayRenderTarget.js";
-export * from "./renderers/WebGLCubeRenderTarget.js";
 export * from "./renderers/WebGLRenderTarget.js";
 export * from "./renderers/webxr/WebXRController.js";
 export * from "./scenes/Fog.js";

three/src/Three.TSL.d.ts

@@ -29,7 +29,6 @@ export const HALF_PI: typeof TSL.HALF_PI;
 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;
@@ -58,7 +57,6 @@ export const arrayBuffer: typeof TSL.arrayBuffer;
 export const asin: typeof TSL.asin;
 export const assign: typeof TSL.assign;
 export const atan: typeof TSL.atan;
-export const atan2: typeof TSL.atan2;
 export const atomicAdd: typeof TSL.atomicAdd;
 export const atomicAnd: typeof TSL.atomicAnd;
 export const atomicFunc: typeof TSL.atomicFunc;
@@ -98,7 +96,6 @@ export const bool: typeof TSL.bool;
 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 builtinAOContext: typeof TSL.builtinAOContext;
 export const builtinShadowContext: typeof TSL.builtinShadowContext;
@@ -127,6 +124,7 @@ 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 clipSpace: typeof TSL.clipSpace;
 export const code: typeof TSL.code;
 export const color: typeof TSL.color;
 export const colorSpaceToWorking: typeof TSL.colorSpaceToWorking;
@@ -169,17 +167,16 @@ export const directionToFaceDirection: typeof TSL.directionToFaceDirection;
 export const dispersion: typeof TSL.dispersion;
 export const distance: typeof TSL.distance;
 export const div: typeof TSL.div;
-export const dodge: typeof TSL.dodge;
 export const dot: typeof TSL.dot;
 export const drawIndex: typeof TSL.drawIndex;
 export const dynamicBufferAttribute: typeof TSL.dynamicBufferAttribute;
 export const element: typeof TSL.element;
 export const emissive: typeof TSL.emissive;
 export const equal: typeof TSL.equal;
-export const equals: typeof TSL.equals;
 export const equirectUV: typeof TSL.equirectUV;
 export const exp: typeof TSL.exp;
 export const exp2: typeof TSL.exp2;
+export const exponentialHeightFogFactor: typeof TSL.exponentialHeightFogFactor;
 export const expression: typeof TSL.expression;
 export const faceDirection: typeof TSL.faceDirection;
 export const faceForward: typeof TSL.faceForward;
@@ -417,7 +414,6 @@ export const oscSquare: typeof TSL.oscSquare;
 export const oscTriangle: typeof TSL.oscTriangle;
 export const output: typeof TSL.output;
 export const outputStruct: typeof TSL.outputStruct;
-export const overlay: typeof TSL.overlay;
 export const overloadingFn: typeof TSL.overloadingFn;
 export const packHalf2x16: typeof TSL.packHalf2x16;
 export const packSnorm2x16: typeof TSL.packSnorm2x16;
@@ -482,13 +478,10 @@ export const sampler: typeof TSL.sampler;
 export const samplerComparison: typeof TSL.samplerComparison;
 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;
@@ -519,7 +512,6 @@ 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;
 export const storageTexture: typeof TSL.storageTexture;
 export const string: typeof TSL.string;
 export const struct: typeof TSL.struct;
@@ -611,11 +603,14 @@ export const vibrance: typeof TSL.vibrance;
 export const viewZToLogarithmicDepth: typeof TSL.viewZToLogarithmicDepth;
 export const viewZToOrthographicDepth: typeof TSL.viewZToOrthographicDepth;
 export const viewZToPerspectiveDepth: typeof TSL.viewZToPerspectiveDepth;
+export const viewZToReversedOrthographicDepth: typeof TSL.viewZToReversedOrthographicDepth;
+export const viewZToReversedPerspectiveDepth: typeof TSL.viewZToReversedPerspectiveDepth;
 export const viewport: typeof TSL.viewport;
 export const viewportCoordinate: typeof TSL.viewportCoordinate;
 export const viewportDepthTexture: typeof TSL.viewportDepthTexture;
 export const viewportLinearDepth: typeof TSL.viewportLinearDepth;
 export const viewportMipTexture: typeof TSL.viewportMipTexture;
+export const viewportOpaqueMipTexture: typeof TSL.viewportOpaqueMipTexture;
 export const viewportResolution: typeof TSL.viewportResolution;
 export const viewportSafeUV: typeof TSL.viewportSafeUV;
 export const viewportSharedTexture: typeof TSL.viewportSharedTexture;
@@ -630,4 +625,4 @@ export const workgroupId: typeof TSL.workgroupId;
 export const workingToColorSpace: typeof TSL.workingToColorSpace;
 export const xor: typeof TSL.xor;
 
-export type { ProxiedObject, Swizzable } from "./nodes/TSL.js";
+export type { ProxiedObject } from "./nodes/TSL.js";

three/src/Three.WebGPU.Nodes.d.ts

@@ -7,6 +7,7 @@ export { default as Lighting } from "./renderers/common/Lighting.js";
 export { default as PostProcessing } from "./renderers/common/PostProcessing.js";
 export { default as QuadMesh } from "./renderers/common/QuadMesh.js";
 export type { default as Renderer } from "./renderers/common/Renderer.js";
+export { default as RenderPipeline } from "./renderers/common/RenderPipeline.js";
 export { default as WebGPURenderer } from "./renderers/webgpu/WebGPURenderer.Nodes.js";
 import * as RendererUtils from "./renderers/common/RendererUtils.js";
 export { RendererUtils };
@@ -16,6 +17,7 @@ export { default as NodeLoader } from "./loaders/nodes/NodeLoader.js";
 export { default as NodeMaterialLoader } from "./loaders/nodes/NodeMaterialLoader.js";
 export { default as NodeObjectLoader } from "./loaders/nodes/NodeObjectLoader.js";
 export * from "./nodes/Nodes.js";
+export { default as BlendMode } from "./renderers/common/BlendMode.js";
 export { default as CanvasTarget } from "./renderers/common/CanvasTarget.js";
 export { default as InspectorBase } from "./renderers/common/InspectorBase.js";
 import * as TSL from "./nodes/TSL.js";

three/src/Three.WebGPU.d.ts

@@ -7,6 +7,7 @@ export { default as Lighting } from "./renderers/common/Lighting.js";
 export { default as PostProcessing } from "./renderers/common/PostProcessing.js";
 export { default as QuadMesh } from "./renderers/common/QuadMesh.js";
 export type { default as Renderer } from "./renderers/common/Renderer.js";
+export { default as RenderPipeline } from "./renderers/common/RenderPipeline.js";
 export { default as WebGPURenderer } from "./renderers/webgpu/WebGPURenderer.js";
 import * as RendererUtils from "./renderers/common/RendererUtils.js";
 export { RendererUtils };
@@ -16,7 +17,9 @@ export { default as NodeLoader } from "./loaders/nodes/NodeLoader.js";
 export { default as NodeMaterialLoader } from "./loaders/nodes/NodeMaterialLoader.js";
 export { default as NodeObjectLoader } from "./loaders/nodes/NodeObjectLoader.js";
 export * from "./nodes/Nodes.js";
+export { default as BlendMode } from "./renderers/common/BlendMode.js";
 export { default as CanvasTarget } from "./renderers/common/CanvasTarget.js";
+export { default as CubeRenderTarget } from "./renderers/common/CubeRenderTarget.js";
 export { default as InspectorBase } from "./renderers/common/InspectorBase.js";
 import * as TSL from "./nodes/TSL.js";
 export { TSL };

three/src/Three.d.ts

@@ -10,8 +10,7 @@ export type { WebGLBindingStates } from "./renderers/webgl/WebGLBindingStates.js
 export type { WebGLBufferRenderer } from "./renderers/webgl/WebGLBufferRenderer.js";
 export type { WebGLCapabilities, WebGLCapabilitiesParameters } from "./renderers/webgl/WebGLCapabilities.js";
 export type { WebGLClipping } from "./renderers/webgl/WebGLClipping.js";
-export type { WebGLCubeMaps } from "./renderers/webgl/WebGLCubeMaps.js";
-export type { WebGLCubeUVMaps } from "./renderers/webgl/WebGLCubeUVMaps.js";
+export type { WebGLEnvironments } from "./renderers/webgl/WebGLEnvironments.js";
 export type { WebGLExtensions } from "./renderers/webgl/WebGLExtensions.js";
 export type { WebGLGeometries } from "./renderers/webgl/WebGLGeometries.js";
 export type { WebGLIndexedBufferRenderer } from "./renderers/webgl/WebGLIndexedBufferRenderer.js";
@@ -37,6 +36,7 @@ export type {
 export type { WebGLTextures } from "./renderers/webgl/WebGLTextures.js";
 export type { WebGLUniforms } from "./renderers/webgl/WebGLUniforms.js";
 export * from "./renderers/webgl/WebGLUtils.js";
+export * from "./renderers/WebGLCubeRenderTarget.js";
 export * from "./renderers/WebGLRenderer.js";
 export type {
     WebXRController,

three/src/animation/AnimationClip.d.ts

@@ -92,7 +92,7 @@ export class AnimationClip {
      * @static
      * @deprecated since r175.
      * @param {Object} animation - A serialized animation clip as JSON.
-     * @param {Array<Bones>} bones - An array of bones.
+     * @param {Array<Bone>} bones - An array of bones.
      * @return {?AnimationClip} The new animation clip.
      */
     static parseAnimation(animation: AnimationClipJSON, bones: Array<Bone>): AnimationClip | null;

three/src/animation/KeyframeTrack.d.ts

@@ -1,5 +1,6 @@
 import { InterpolationModes } from "../constants.js";
 import { TypedArray, TypedArrayConstructor } from "../core/BufferAttribute.js";
+import { BezierInterpolant } from "../math/interpolants/BezierInterpolant.js";
 import { CubicInterpolant } from "../math/interpolants/CubicInterpolant.js";
 import { DiscreteInterpolant } from "../math/interpolants/DiscreteInterpolant.js";
 import { LinearInterpolant } from "../math/interpolants/LinearInterpolant.js";
@@ -13,7 +14,7 @@ export interface KeyframeTrackJSON {
 }
 
 /**
- * Represents s a timed sequence of keyframes, which are composed of lists of
+ * Represents a timed sequence of keyframes, which are composed of lists of
  * times and related values, and which are used to animate a specific property
  * of an object.
  */
@@ -32,7 +33,7 @@ export class KeyframeTrack {
      * @param {string} name - The keyframe track's name.
      * @param {Array<number>} times - A list of keyframe times.
      * @param {Array<number|string|boolean>} values - A list of keyframe values.
-     * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+     * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth|InterpolateBezier)} [interpolation] - The interpolation type.
      */
     constructor(
         name: string,
@@ -78,17 +79,30 @@ export class KeyframeTrack {
      * @return {CubicInterpolant} The new interpolant.
      */
     InterpolantFactoryMethodSmooth(result?: TypedArray): CubicInterpolant;
+    /**
+     * Factory method for creating a new Bezier interpolant.
+     *
+     * The Bezier interpolant requires tangent data to be set via the `settings` property
+     * on the track before creating the interpolant. The settings should contain:
+     * - `inTangents`: Float32Array with [time, value] pairs per keyframe per component
+     * - `outTangents`: Float32Array with [time, value] pairs per keyframe per component
+     *
+     * @static
+     * @param {TypedArray} [result] - The result buffer.
+     * @return {BezierInterpolant} The new interpolant.
+     */
+    InterpolantFactoryMethodBezier(result?: TypedArray): BezierInterpolant;
     /**
      * Defines the interpolation factor method for this keyframe track.
      *
-     * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} interpolation - The interpolation type.
+     * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth|InterpolateBezier)} interpolation - The interpolation type.
      * @return {KeyframeTrack} A reference to this keyframe track.
      */
     setInterpolation(interpolation: InterpolationModes): KeyframeTrack;
     /**
      * Returns the current interpolation type.
      *
-     * @return {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} The interpolation type.
+     * @return {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth|InterpolateBezier)} The interpolation type.
      */
     getInterpolation(): InterpolationModes;
     /**
@@ -133,7 +147,7 @@ export class KeyframeTrack {
      * Optimizes this keyframe track by removing equivalent sequential keys (which are
      * common in morph target sequences).
      *
-     * @return {AnimationClip} A reference to this animation clip.
+     * @return {KeyframeTrack} A reference to this keyframe track.
      */
     optimize(): this;
     /**

three/src/animation/PropertyMixer.d.ts

@@ -20,26 +20,27 @@ export class PropertyMixer {
      * The keyframe track value size.
      */
     valueSize: number;
+    buffer: Float64Array | unknown[];
     /**
-     * TODO
+     * Accumulated weight of the property binding.
      *
      * @default 0
      */
     cumulativeWeight: number;
     /**
-     * TODO
+     * Accumulated additive weight of the property binding.
      *
      * @default 0
      */
     cumulativeWeightAdditive: number;
     /**
-     * TODO
+     * Number of active keyframe tracks currently using this property binding.
      *
      * @default 0
      */
     useCount: number;
     /**
-     * TODO
+     * Number of keyframe tracks referencing this property binding.
      *
      * @default 0
      */