@types/three 0.181.0 → 0.183.0

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/display/radialBlur.d.ts

@@ -0,0 +1,12 @@
+import { Node } from "three/webgpu";
+
+export interface RadialBlurOptions {
+    center?: Node | undefined;
+    weight?: Node | undefined;
+    decay?: Node | undefined;
+    count?: Node | undefined;
+    exposure?: Node | undefined;
+    premultipliedAlpha?: boolean | undefined;
+}
+
+export const radialBlur: (textureNode: Node, options?: RadialBlurOptions) => Node;

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.181.0",
+    "version": "0.183.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -43,12 +43,12 @@
         "@dimforge/rapier3d-compat": "~0.12.0",
         "@tweenjs/tween.js": "~23.1.3",
         "@types/stats.js": "*",
-        "@types/webxr": "*",
+        "@types/webxr": ">=0.5.17",
         "@webgpu/types": "*",
         "fflate": "~0.8.2",
-        "meshoptimizer": "~0.22.0"
+        "meshoptimizer": "~1.0.1"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "d4f610987bd76c1162c3a6a2221b72979499c9bc94a8d25712df1534d6b1bb87",
+    "typesPublisherContentHash": "d921c36975e556bd8c1960f56fd373c30df7106ac1484665e6bdc2ddce8100fc",
     "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

@@ -7,7 +7,7 @@ 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 DFGLUT: typeof TSL.DFGLUT;
 export const D_GGX: typeof TSL.D_GGX;
 export const Discard: typeof TSL.Discard;
 export const EPSILON: typeof TSL.EPSILON;
@@ -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,8 +96,9 @@ 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;
 export const bvec2: typeof TSL.bvec2;
 export const bvec3: typeof TSL.bvec3;
 export const bvec4: typeof TSL.bvec4;
@@ -125,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;
@@ -136,11 +136,13 @@ export const context: typeof TSL.context;
 export const convert: typeof TSL.convert;
 export const convertColorSpace: typeof TSL.convertColorSpace;
 export const convertToTexture: typeof TSL.convertToTexture;
+export const countLeadingZeros: typeof TSL.countLeadingZeros;
+export const countOneBits: typeof TSL.countOneBits;
+export const countTrailingZeros: typeof TSL.countTrailingZeros;
 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;
@@ -165,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;
@@ -199,6 +200,7 @@ export const getDistanceAttenuation: typeof TSL.getDistanceAttenuation;
 export const getGeometryRoughness: typeof TSL.getGeometryRoughness;
 export const getNormalFromDepth: typeof TSL.getNormalFromDepth;
 export const interleavedGradientNoise: typeof TSL.interleavedGradientNoise;
+export const vogelDiskSample: typeof TSL.vogelDiskSample;
 export const getParallaxCorrectNormal: typeof TSL.getParallaxCorrectNormal;
 export const getRoughness: typeof TSL.getRoughness;
 export const getScreenPosition: typeof TSL.getScreenPosition;
@@ -412,8 +414,10 @@ 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;
+export const packUnorm2x16: typeof TSL.packUnorm2x16;
 export const parabola: typeof TSL.parabola;
 export const parallaxDirection: typeof TSL.parallaxDirection;
 export const parallaxUV: typeof TSL.parallaxUV;
@@ -461,6 +465,7 @@ export const remapClamp: typeof TSL.remapClamp;
 export const renderGroup: typeof TSL.renderGroup;
 export const renderOutput: typeof TSL.renderOutput;
 export const rendererReference: typeof TSL.rendererReference;
+export const replaceDefaultUV: typeof TSL.replaceDefaultUV;
 export const rotate: typeof TSL.rotate;
 export const rotateUV: typeof TSL.rotateUV;
 export const roughness: typeof TSL.roughness;
@@ -473,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;
@@ -510,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;
@@ -579,6 +580,9 @@ 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 unpackHalf2x16: typeof TSL.unpackHalf2x16;
+export const unpackSnorm2x16: typeof TSL.unpackSnorm2x16;
+export const unpackUnorm2x16: typeof TSL.unpackUnorm2x16;
 export const unpremultiplyAlpha: typeof TSL.unpremultiplyAlpha;
 export const userData: typeof TSL.userData;
 export const uv: typeof TSL.uv;
@@ -599,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;
@@ -618,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/AnimationMixer.d.ts

@@ -1,15 +1,36 @@
 import { AnimationBlendMode } from "../constants.js";
 import { EventDispatcher } from "../core/EventDispatcher.js";
 import { Object3D } from "../core/Object3D.js";
+import { LinearInterpolant } from "../math/interpolants/LinearInterpolant.js";
 import { AnimationAction } from "./AnimationAction.js";
 import { AnimationClip } from "./AnimationClip.js";
 import { AnimationObjectGroup } from "./AnimationObjectGroup.js";
+import { PropertyMixer } from "./PropertyMixer.js";
 
 export interface AnimationMixerEventMap {
     loop: { action: AnimationAction; loopDelta: number };
     finished: { action: AnimationAction; direction: number };
 }
 
+export interface MixerControlInterpolant extends LinearInterpolant {
+    __cacheIndex: number;
+}
+
+export interface AnimationMixerStats {
+    actions: {
+        readonly total: number;
+        readonly inUse: number;
+    };
+    bindings: {
+        readonly total: number;
+        readonly inUse: number;
+    };
+    controlInterpolants: {
+        readonly total: number;
+        readonly inUse: number;
+    };
+}
+
 /**
  * `AnimationMixer` is a player for animations on a particular object in
  * the scene. When multiple objects in the scene are animated independently,
@@ -28,6 +49,23 @@ export class AnimationMixer extends EventDispatcher<AnimationMixerEventMap> {
      * @default 0
      */
     time: number;
+    protected _root: Object3D | AnimationObjectGroup;
+    protected _actions: AnimationAction[];
+    protected _nActiveActions: number;
+    protected _bindings: PropertyMixer[];
+    protected _nActiveBindings: number;
+    protected _controlInterpolants: MixerControlInterpolant[];
+    protected _nActiveControlInterpolants: number;
+    protected _bindingsByRootAndName: {
+        [rootUuid: string]: { [trackName: string]: PropertyMixer };
+    };
+    protected _actionsByClip: {
+        [clipUuid: string]: {
+            knownActions: AnimationAction[];
+            actionByRoot: { [rootUuid: string]: AnimationAction };
+        };
+    };
+    protected _accuIndex: number;
     /**
      * A scaling factor for the global time.
      *
@@ -38,6 +76,10 @@ export class AnimationMixer extends EventDispatcher<AnimationMixerEventMap> {
      * @default 1
      */
     timeScale: number;
+    /**
+     * The AnimationMixer stats track the actions of the mixer.
+     */
+    stats: AnimationMixerStats;
     /**
      * Returns an instance of {@link AnimationAction} for the passed clip.
      *

three/src/animation/AnimationUtils.d.ts

@@ -1,4 +1,5 @@
 import { TypedArray, TypedArrayConstructor } from "../core/BufferAttribute.js";
+import { isTypedArray } from "../utils.js";
 import { AnimationClip } from "./AnimationClip.js";
 
 /**
@@ -8,14 +9,7 @@ import { AnimationClip } from "./AnimationClip.js";
  * @param {TypedArray.constructor} type - The constructor of a typed array that defines the new type.
  * @return {TypedArray} The converted array.
  */
-export function convertArray(array: TypedArray | number[], type: TypedArrayConstructor): TypedArray | number[];
-/**
- * Returns `true` if the given object is a typed array.
- *
- * @param {any} object - The object to check.
- * @return {boolean} Whether the given object is a typed array.
- */
-export function isTypedArray(object: unknown): boolean;
+export function convertArray(array: TypedArray | number[], type: TypedArrayConstructor): TypedArray;
 /**
  * Returns an array by which times and values can be sorted.
  *
@@ -169,3 +163,4 @@ export class AnimationUtils {
         fps?: number,
     ): AnimationClip;
 }
+export { isTypedArray };

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
      */