@types/three 0.184.0 → 0.185.0

three/src/math/Matrix4.d.ts

@@ -24,38 +24,69 @@ export type Matrix4Tuple = [
 ];
 
 /**
- * A 4x4 Matrix.
+ * Represents a 4x4 matrix.
  *
- * @example
- * // Simple rig for rotating around 3 axes
+ * The most common use of a 4x4 matrix in 3D computer graphics is as a transformation matrix.
+ * For an introduction to transformation matrices as used in WebGL, check out [this tutorial](https://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices)
+ *
+ * This allows a 3D vector representing a point in 3D space to undergo
+ * transformations such as translation, rotation, shear, scale, reflection,
+ * orthogonal or perspective projection and so on, by being multiplied by the
+ * matrix. This is known as `applying` the matrix to the vector.
+ *
+ * A Note on Row-Major and Column-Major Ordering:
+ *
+ * The constructor and {@link Matrix3#set} method take arguments in
+ * [row-major](https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order)
+ * order, while internally they are stored in the {@link Matrix3#elements} array in column-major order.
+ * This means that calling:
+ * ```js
  * const m = new THREE.Matrix4();
- * const m1 = new THREE.Matrix4();
- * const m2 = new THREE.Matrix4();
- * const m3 = new THREE.Matrix4();
- * const alpha = 0;
- * const beta = Math.PI;
- * const gamma = Math.PI/2;
- * m1.makeRotationX( alpha );
- * m2.makeRotationY( beta );
- * m3.makeRotationZ( gamma );
- * m.multiplyMatrices( m1, m2 );
- * m.multiply( m3 );
+ * m.set( 11, 12, 13, 14,
+ *        21, 22, 23, 24,
+ *        31, 32, 33, 34,
+ *        41, 42, 43, 44 );
+ * ```
+ * will result in the elements array containing:
+ * ```js
+ * m.elements = [ 11, 21, 31, 41,
+ *                12, 22, 32, 42,
+ *                13, 23, 33, 43,
+ *                14, 24, 34, 44 ];
+ * ```
+ * and internally all calculations are performed using column-major ordering.
+ * However, as the actual ordering makes no difference mathematically and
+ * most people are used to thinking about matrices in row-major order, the
+ * three.js documentation shows matrices in row-major order. Just bear in
+ * mind that if you are reading the source code, you'll have to take the
+ * transpose of any matrices outlined here to make sense of the calculations.
  */
 export class Matrix4 {
-    static readonly isMatrix4: boolean;
-
-    /**
-     * Array with matrix values.
-     * @default [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
-     */
-    elements: Matrix4Tuple;
-
     /**
-     * Creates an identity matrix.
+     * Constructs a new 4x4 matrix. This constructor
+     * initializes the matrix as an identity matrix.
      */
     constructor();
     /**
-     * Creates a 4x4 matrix with the given arguments in row-major order.
+     * Constructs a new 4x4 matrix. The arguments are supposed to be
+     * in row-major order.
+     *
+     * @param {number} [n11] - 1-1 matrix element.
+     * @param {number} [n12] - 1-2 matrix element.
+     * @param {number} [n13] - 1-3 matrix element.
+     * @param {number} [n14] - 1-4 matrix element.
+     * @param {number} [n21] - 2-1 matrix element.
+     * @param {number} [n22] - 2-2 matrix element.
+     * @param {number} [n23] - 2-3 matrix element.
+     * @param {number} [n24] - 2-4 matrix element.
+     * @param {number} [n31] - 3-1 matrix element.
+     * @param {number} [n32] - 3-2 matrix element.
+     * @param {number} [n33] - 3-3 matrix element.
+     * @param {number} [n34] - 3-4 matrix element.
+     * @param {number} [n41] - 4-1 matrix element.
+     * @param {number} [n42] - 4-2 matrix element.
+     * @param {number} [n43] - 4-3 matrix element.
+     * @param {number} [n44] - 4-4 matrix element.
      */
     constructor(
         n11: number,
@@ -75,9 +106,33 @@ export class Matrix4 {
         n43: number,
         n44: number,
     );
-
     /**
-     * Sets all fields of this matrix.
+     * A column-major list of matrix values.
+     *
+     * @type {Array<number>}
+     */
+    elements: Matrix4Tuple;
+    /**
+     * Sets the elements of the matrix.The arguments are supposed to be
+     * in row-major order.
+     *
+     * @param {number} [n11] - 1-1 matrix element.
+     * @param {number} [n12] - 1-2 matrix element.
+     * @param {number} [n13] - 1-3 matrix element.
+     * @param {number} [n14] - 1-4 matrix element.
+     * @param {number} [n21] - 2-1 matrix element.
+     * @param {number} [n22] - 2-2 matrix element.
+     * @param {number} [n23] - 2-3 matrix element.
+     * @param {number} [n24] - 2-4 matrix element.
+     * @param {number} [n31] - 3-1 matrix element.
+     * @param {number} [n32] - 3-2 matrix element.
+     * @param {number} [n33] - 3-3 matrix element.
+     * @param {number} [n34] - 3-4 matrix element.
+     * @param {number} [n41] - 4-1 matrix element.
+     * @param {number} [n42] - 4-2 matrix element.
+     * @param {number} [n43] - 4-3 matrix element.
+     * @param {number} [n44] - 4-4 matrix element.
+     * @return {Matrix4} A reference to this matrix.
      */
     set(
         n11: number,
@@ -97,146 +152,303 @@ export class Matrix4 {
         n43: number,
         n44: number,
     ): this;
-
     /**
-     * Resets this matrix to identity.
+     * Sets this matrix to the 4x4 identity matrix.
+     *
+     * @return {Matrix4} A reference to this matrix.
      */
     identity(): this;
-
+    /**
+     * Returns a matrix with copied values from this instance.
+     *
+     * @return {Matrix4} A clone of this instance.
+     */
     clone(): Matrix4;
-
+    /**
+     * Copies the values of the given matrix to this instance.
+     *
+     * @param {Matrix4} m - The matrix to copy.
+     * @return {Matrix4} A reference to this matrix.
+     */
     copy(m: Matrix4): this;
-
+    /**
+     * Copies the translation component of the given matrix
+     * into this matrix's translation component.
+     *
+     * @param {Matrix4} m - The matrix to copy the translation component.
+     * @return {Matrix4} A reference to this matrix.
+     */
     copyPosition(m: Matrix4): this;
-
     /**
-     * Set the upper 3x3 elements of this matrix to the values of the Matrix3 m.
+     * Set the upper 3x3 elements of this matrix to the values of given 3x3 matrix.
+     *
+     * @param {Matrix3} m - The 3x3 matrix.
+     * @return {Matrix4} A reference to this matrix.
      */
     setFromMatrix3(m: Matrix3): this;
-
+    /**
+     * Extracts the basis of this matrix into the three axis vectors provided.
+     *
+     * @param {Vector3} xAxis - The basis's x axis.
+     * @param {Vector3} yAxis - The basis's y axis.
+     * @param {Vector3} zAxis - The basis's z axis.
+     * @return {Matrix4} A reference to this matrix.
+     */
     extractBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): this;
-
+    /**
+     * Sets the given basis vectors to this matrix.
+     *
+     * @param {Vector3} xAxis - The basis's x axis.
+     * @param {Vector3} yAxis - The basis's y axis.
+     * @param {Vector3} zAxis - The basis's z axis.
+     * @return {Matrix4} A reference to this matrix.
+     */
     makeBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): this;
-
     /**
-     * Copies the rotation component of the supplied matrix m into this matrix rotation component.
+     * Extracts the rotation component of the given matrix
+     * into this matrix's rotation component.
+     *
+     * Note: This method does not support reflection matrices.
+     *
+     * @param {Matrix4} m - The matrix.
+     * @return {Matrix4} A reference to this matrix.
      */
     extractRotation(m: Matrix4): this;
-
+    /**
+     * Sets the rotation component (the upper left 3x3 matrix) of this matrix to
+     * the rotation specified by the given Euler angles. The rest of
+     * the matrix is set to the identity. Depending on the {@link Euler#order},
+     * there are six possible outcomes. See [this page](https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix)
+     * for a complete list.
+     *
+     * @param {Euler} euler - The Euler angles.
+     * @return {Matrix4} A reference to this matrix.
+     */
     makeRotationFromEuler(euler: Euler): this;
-
+    /**
+     * Sets the rotation component of this matrix to the rotation specified by
+     * the given Quaternion as outlined [here](https://en.wikipedia.org/wiki/Rotation_matrix#Quaternion)
+     * The rest of the matrix is set to the identity.
+     *
+     * @param {Quaternion} q - The Quaternion.
+     * @return {Matrix4} A reference to this matrix.
+     */
     makeRotationFromQuaternion(q: Quaternion): this;
-
     /**
-     * Sets the rotation component of the transformation matrix, looking from [eye]{@link Vector3} towards
-     * [target]{@link Vector3}, and oriented by the up-direction [up]{@link Vector3}.
+     * Sets the rotation component of the transformation matrix, looking from `eye` towards
+     * `target`, and oriented by the up-direction.
+     *
+     * @param {Vector3} eye - The eye vector.
+     * @param {Vector3} target - The target vector.
+     * @param {Vector3} up - The up vector.
+     * @return {Matrix4} A reference to this matrix.
      */
     lookAt(eye: Vector3, target: Vector3, up: Vector3): this;
-
     /**
-     * Multiplies this matrix by m.
+     * Post-multiplies this matrix by the given 4x4 matrix.
+     *
+     * @param {Matrix4} m - The matrix to multiply with.
+     * @return {Matrix4} A reference to this matrix.
      */
     multiply(m: Matrix4): this;
-
+    /**
+     * Pre-multiplies this matrix by the given 4x4 matrix.
+     *
+     * @param {Matrix4} m - The matrix to multiply with.
+     * @return {Matrix4} A reference to this matrix.
+     */
     premultiply(m: Matrix4): this;
-
     /**
-     * Sets this matrix to a x b.
+     * Multiples the given 4x4 matrices and stores the result
+     * in this matrix.
+     *
+     * @param {Matrix4} a - The first matrix.
+     * @param {Matrix4} b - The second matrix.
+     * @return {Matrix4} A reference to this matrix.
      */
     multiplyMatrices(a: Matrix4, b: Matrix4): this;
-
     /**
-     * Multiplies this matrix by s.
+     * Multiplies every component of the matrix by the given scalar.
+     *
+     * @param {number} s - The scalar.
+     * @return {Matrix4} A reference to this matrix.
      */
     multiplyScalar(s: number): this;
-
     /**
-     * Computes determinant of this matrix.
-     * Based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
+     * Computes and returns the determinant of this matrix.
+     *
+     * Based on the method outlined [here](http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.html).
+     *
+     * @return {number} The determinant.
      */
     determinant(): number;
-
     /**
-     * Transposes this matrix.
+     * Computes and returns the determinant of the 4x4 matrix, but assumes the
+     * matrix is affine, saving some computations.
+     *
+     * For affine matrices (like an object's world matrix), this value equals the
+     * full 4x4 {@link Matrix4#determinant} but is cheaper to compute.
+     *
+     * Assumes the bottom row is [0, 0, 0, 1].
+     *
+     * @return {number} The determinant of the matrix.
+     */
+    determinantAffine(): number;
+    /**
+     * Transposes this matrix in place.
+     *
+     * @return {Matrix4} A reference to this matrix.
      */
     transpose(): this;
-
     /**
-     * Sets the position component for this matrix from vector v.
+     * Sets the position component for this matrix from the given vector,
+     * without affecting the rest of the matrix.
+     *
+     * @param {number|Vector3} v - The vector object.
+     * @return {Matrix4} A reference to this matrix.
      */
     setPosition(v: Vector3): this;
+    /**
+     * Sets the position component for this matrix from the given vector,
+     * without affecting the rest of the matrix.
+     *
+     * @param {number} x - The x component of the vector.
+     * @param {number} y - The y component of the vector.
+     * @param {number} z - The z component of the vector.
+     * @return {Matrix4} A reference to this matrix.
+     */
     setPosition(x: number, y: number, z: number): this;
-
     /**
-     * Inverts this matrix.
+     * Inverts this matrix, using the [analytic method](https://en.wikipedia.org/wiki/Invertible_matrix#Analytic_solution).
+     * You can not invert with a determinant of zero. If you attempt this, the method produces
+     * a zero matrix instead.
+     *
+     * @return {Matrix4} A reference to this matrix.
      */
     invert(): this;
-
     /**
-     * Multiplies the columns of this matrix by vector v.
+     * Multiplies the columns of this matrix by the given vector.
+     *
+     * @param {Vector3} v - The scale vector.
+     * @return {Matrix4} A reference to this matrix.
      */
     scale(v: Vector3): this;
-
+    /**
+     * Gets the maximum scale value of the three axes.
+     *
+     * @return {number} The maximum scale.
+     */
     getMaxScaleOnAxis(): number;
-
     /**
-     * Sets this matrix as translation transform.
+     * Sets this matrix as a translation transform from the given vector.
+     *
+     * @param {Vector3} v - A translation vector.
+     * @return {Matrix4} A reference to this matrix.
      */
     makeTranslation(v: Vector3): this;
+    /**
+     * Sets this matrix as a translation transform from the given vector.
+     *
+     * @param {number} x - The amount to translate in the X axis.
+     * @param {number} y - The amount to translate in the Y axis.
+     * @param {number} z - The amount to translate in the z axis.
+     * @return {Matrix4} A reference to this matrix.
+     */
     makeTranslation(x: number, y: number, z: number): this;
-
     /**
-     * Sets this matrix as rotation transform around x axis by theta radians.
+     * Sets this matrix as a rotational transformation around the X axis by
+     * the given angle.
      *
-     * @param theta Rotation angle in radians.
+     * @param {number} theta - The rotation in radians.
+     * @return {Matrix4} A reference to this matrix.
      */
     makeRotationX(theta: number): this;
-
     /**
-     * Sets this matrix as rotation transform around y axis by theta radians.
+     * Sets this matrix as a rotational transformation around the Y axis by
+     * the given angle.
      *
-     * @param theta Rotation angle in radians.
+     * @param {number} theta - The rotation in radians.
+     * @return {Matrix4} A reference to this matrix.
      */
     makeRotationY(theta: number): this;
-
     /**
-     * Sets this matrix as rotation transform around z axis by theta radians.
+     * Sets this matrix as a rotational transformation around the Z axis by
+     * the given angle.
      *
-     * @param theta Rotation angle in radians.
+     * @param {number} theta - The rotation in radians.
+     * @return {Matrix4} A reference to this matrix.
      */
     makeRotationZ(theta: number): this;
-
     /**
-     * Sets this matrix as rotation transform around axis by angle radians.
-     * Based on http://www.gamedev.net/reference/articles/article1199.asp.
+     * Sets this matrix as a rotational transformation around the given axis by
+     * the given angle.
+     *
+     * This is a somewhat controversial but mathematically sound alternative to
+     * rotating via Quaternions. See the discussion [here](https://www.gamedev.net/articles/programming/math-and-physics/do-we-really-need-quaternions-r1199).
      *
-     * @param axis Rotation axis.
-     * @param angle Rotation angle in radians.
+     * @param {Vector3} axis - The normalized rotation axis.
+     * @param {number} angle - The rotation in radians.
+     * @return {Matrix4} A reference to this matrix.
      */
     makeRotationAxis(axis: Vector3, angle: number): this;
-
     /**
-     * Sets this matrix as scale transform.
+     * Sets this matrix as a scale transformation.
+     *
+     * @param {number} x - The amount to scale in the X axis.
+     * @param {number} y - The amount to scale in the Y axis.
+     * @param {number} z - The amount to scale in the Z axis.
+     * @return {Matrix4} A reference to this matrix.
      */
     makeScale(x: number, y: number, z: number): this;
-
     /**
-     * Sets this matrix as shear transform.
+     * Sets this matrix as a shear transformation.
+     *
+     * @param {number} xy - The amount to shear X by Y.
+     * @param {number} xz - The amount to shear X by Z.
+     * @param {number} yx - The amount to shear Y by X.
+     * @param {number} yz - The amount to shear Y by Z.
+     * @param {number} zx - The amount to shear Z by X.
+     * @param {number} zy - The amount to shear Z by Y.
+     * @return {Matrix4} A reference to this matrix.
      */
     makeShear(xy: number, xz: number, yx: number, yz: number, zx: number, zy: number): this;
-
     /**
-     * Sets this matrix to the transformation composed of translation, rotation and scale.
+     * Sets this matrix to the transformation composed of the given position,
+     * rotation (Quaternion) and scale.
+     *
+     * @param {Vector3} position - The position vector.
+     * @param {Quaternion} quaternion - The rotation as a Quaternion.
+     * @param {Vector3} scale - The scale vector.
+     * @return {Matrix4} A reference to this matrix.
      */
     compose(position: Vector3, quaternion: Quaternion, scale: Vector3): this;
-
     /**
-     * Decomposes this matrix into it's position, quaternion and scale components.
+     * Decomposes this matrix into its position, rotation and scale components
+     * and provides the result in the given objects.
+     *
+     * Note: Not all matrices are decomposable in this way. For example, if an
+     * object has a non-uniformly scaled parent, then the object's world matrix
+     * may not be decomposable, and this method may not be appropriate.
+     *
+     * @param {Vector3} position - The position vector.
+     * @param {Quaternion} quaternion - The rotation as a Quaternion.
+     * @param {Vector3} scale - The scale vector.
+     * @return {Matrix4} A reference to this matrix.
      */
     decompose(position: Vector3, quaternion: Quaternion, scale: Vector3): this;
-
     /**
-     * Creates a perspective projection matrix.
+     * Creates a perspective projection matrix. This is used internally by
+     * {@link PerspectiveCamera#updateProjectionMatrix}.
+
+     * @param {number} left - Left boundary of the viewing frustum at the near plane.
+     * @param {number} right - Right boundary of the viewing frustum at the near plane.
+     * @param {number} top - Top boundary of the viewing frustum at the near plane.
+     * @param {number} bottom - Bottom boundary of the viewing frustum at the near plane.
+     * @param {number} near - The distance from the camera to the near plane.
+     * @param {number} far - The distance from the camera to the far plane.
+     * @param {(WebGLCoordinateSystem|WebGPUCoordinateSystem)} [coordinateSystem=WebGLCoordinateSystem] - The coordinate system.
+     * @param {boolean} [reversedDepth=false] - Whether to use a reversed depth.
+     * @return {Matrix4} A reference to this matrix.
      */
     makePerspective(
         left: number,
@@ -248,9 +460,19 @@ export class Matrix4 {
         coordinateSystem?: CoordinateSystem,
         reversedDepth?: boolean,
     ): this;
-
     /**
-     * Creates an orthographic projection matrix.
+     * Creates a orthographic projection matrix. This is used internally by
+     * {@link OrthographicCamera#updateProjectionMatrix}.
+
+     * @param {number} left - Left boundary of the viewing frustum at the near plane.
+     * @param {number} right - Right boundary of the viewing frustum at the near plane.
+     * @param {number} top - Top boundary of the viewing frustum at the near plane.
+     * @param {number} bottom - Bottom boundary of the viewing frustum at the near plane.
+     * @param {number} near - The distance from the camera to the near plane.
+     * @param {number} far - The distance from the camera to the far plane.
+     * @param {(WebGLCoordinateSystem|WebGPUCoordinateSystem)} [coordinateSystem=WebGLCoordinateSystem] - The coordinate system.
+     * @param {boolean} [reversedDepth=false] - Whether to use a reversed depth.
+     * @return {Matrix4} A reference to this matrix.
      */
     makeOrthographic(
         left: number,
@@ -262,26 +484,28 @@ export class Matrix4 {
         coordinateSystem?: CoordinateSystem,
         reversedDepth?: boolean,
     ): this;
-
-    equals(matrix: Matrix4): boolean;
-
     /**
-     * Sets the values of this matrix from the provided array or array-like.
-     * @param array the source array or array-like.
-     * @param offset (optional) offset into the array-like. Default is 0.
+     * Returns `true` if this matrix is equal with the given one.
+     *
+     * @param {Matrix4} matrix - The matrix to test for equality.
+     * @return {boolean} Whether this matrix is equal with the given one.
      */
-    fromArray(array: ArrayLike<number>, offset?: number): this;
-
+    equals(matrix: Matrix4): boolean;
     /**
-     * Writes the elements of this matrix to an array in
-     * {@link https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order column-major} format.
+     * Sets the elements of the matrix from the given array.
+     *
+     * @param {Array<number>} array - The matrix elements in column-major order.
+     * @param {number} [offset=0] - Index of the first element in the array.
+     * @return {Matrix4} A reference to this matrix.
      */
-    toArray(): Matrix4Tuple;
+    fromArray(array: ArrayLike<number>, offset?: number): this;
     /**
-     * Writes the elements of this matrix to an array in
-     * {@link https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order column-major} format.
-     * @param array array to store the resulting vector in.
-     * @param offset (optional) offset in the array at which to put the result.
+     * Writes the elements of this matrix to the given array. If no array is provided,
+     * the method returns a new instance.
+     *
+     * @param {Array<number>} [array=[]] - The target array holding the matrix elements in column-major order.
+     * @param {number} [offset=0] - Index of the first element in the array.
+     * @return {Array<number>} The matrix elements in column-major order.
      */
-    toArray<TArray extends ArrayLike<number>>(array: TArray, offset?: number): TArray;
+    toArray<TArray extends ArrayLike<number> = Matrix4Tuple>(array?: TArray, offset?: number): TArray;
 }

three/src/math/Vector2.d.ts

@@ -12,8 +12,6 @@ export interface Vector2Like {
  * 2D vector.
  */
 export class Vector2 {
-    static readonly isVector2: boolean;
-
     constructor(x?: number, y?: number);
 
     /**
@@ -27,6 +25,7 @@ export class Vector2 {
     y: number;
     width: number;
     height: number;
+    readonly isVector2: true;
 
     /**
      * Sets value of this vector.

three/src/math/Vector3.d.ts

@@ -29,8 +29,6 @@ export interface Vector3Like {
  * c.crossVectors( a, b );
  */
 export class Vector3 {
-    static readonly isVector3: boolean;
-
     constructor(x?: number, y?: number, z?: number);
 
     /**
@@ -47,11 +45,12 @@ export class Vector3 {
      * @default 0
      */
     z: number;
+    readonly isVector3: true;
 
     /**
      * Sets value of this vector.
      */
-    set(x: number, y: number, z: number): this;
+    set(x: number, y: number, z?: number): this;
 
     /**
      * Sets all values of this vector.
@@ -217,7 +216,7 @@ export class Vector3 {
     crossVectors(a: Vector3Like, b: Vector3Like): this;
     projectOnVector(v: Vector3): this;
     projectOnPlane(planeNormal: Vector3): this;
-    reflect(vector: Vector3Like): this;
+    reflect(normal: Vector3Like): this;
     angleTo(v: Vector3): number;
 
     /**

three/src/math/Vector4.d.ts

@@ -15,8 +15,6 @@ export interface Vector4Like {
  * 4D vector.
  */
 export class Vector4 {
-    static readonly isVector4: boolean;
-
     constructor(x?: number, y?: number, z?: number, w?: number);
 
     /**
@@ -41,6 +39,7 @@ export class Vector4 {
 
     width: number;
     height: number;
+    readonly isVector4: true;
 
     /**
      * Sets value of this vector.

three/src/math/interpolants/BezierInterpolant.d.ts

@@ -1,7 +1,23 @@
+import { TypedArray } from "../../core/BufferAttribute.js";
 import { Interpolant } from "../Interpolant.js";
 
+/**
+ * A Bezier interpolant using cubic Bezier curves with 2D control points.
+ *
+ * This interpolant supports the COLLADA/Maya style of Bezier animation where
+ * each keyframe has explicit in/out tangent control points specified as
+ * 2D coordinates (time, value).
+ *
+ * Tangent data is read from `inTangents` and `outTangents` on the interpolant
+ * (populated by `KeyframeTrack.InterpolantFactoryMethodBezier`).
+ *
+ * For a track with N keyframes and stride S:
+ * - Each tangent array has N * S * 2 values
+ * - Layout: [k0_c0_time, k0_c0_value, k0_c1_time, k0_c1_value, ..., k0_cS_time, k0_cS_value,
+ *            k1_c0_time, k1_c0_value, ...]
+ *
+ * @augments Interpolant
+ */
 export class BezierInterpolant extends Interpolant {
-    constructor(parameterPositions: any, samplesValues: any, sampleSize: number, resultBuffer?: any);
-
-    interpolate_(i1: number, t0: number, t: number, t1: number): any;
+    interpolate_(i1: number, t0: number, t: number, t1: number): TypedArray;
 }