@types/three 0.149.0 → 0.150.1

three/src/geometries/SphereGeometry.d.ts

@@ -1,20 +1,35 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * A class for generating sphere geometries.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.SphereGeometry(15, 32, 16);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const sphere = new THREE.Mesh(geometry, material);
+ * scene.add(sphere);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/SphereGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/SphereGeometry.js | Source}
+ */
 export class SphereGeometry extends BufferGeometry {
     /**
+     * Create a new instance of {@link SphereGeometry}
+     * @remarks
      * The geometry is created by sweeping and calculating vertexes
-     * around the Y axis (horizontal sweep) and the Z axis (vertical sweep).
+     * around the **Y** axis (horizontal sweep) and the **Z** axis (vertical sweep)
      * Thus, incomplete spheres (akin to `'sphere slices'`) can be created
-     * through the use of different values of phiStart, phiLength, thetaStart and thetaLength,
+     * through the use of different values of {@link phiStart}, {@link phiLength}, {@link thetaStart} and {@link thetaLength},
      * in order to define the points in which we start (or end) calculating those vertices.
-     *
-     * @param [radius=50] - sphere radius. Default is 50.
-     * @param [widthSegments=8] - number of horizontal segments. Minimum value is 3, and the default is 32.
-     * @param [heightSegments=6] - number of vertical segments. Minimum value is 2, and the default is 16.
-     * @param [phiStart=0] - specify horizontal starting angle. Default is 0.
-     * @param [phiLength=Math.PI * 2] - specify horizontal sweep angle size. Default is Math.PI * 2.
-     * @param [thetaStart=0] - specify vertical starting angle. Default is 0.
-     * @param [thetaLength=Math.PI * 2] - specify vertical sweep angle size. Default is Math.PI.
+     * @param radius Sphere radius. Expects a `Float`. Default `1`
+     * @param widthSegments Number of horizontal segments. Minimum value is 3, and the Expects a `Integer`. Default `32`
+     * @param heightSegments Number of vertical segments. Minimum value is 2, and the Expects a `Integer`. Default `16`
+     * @param phiStart Specify horizontal starting angle. Expects a `Float`. Default `0`
+     * @param phiLength Specify horizontal sweep angle size. Expects a `Float`. Default `Math.PI * 2`
+     * @param thetaStart Specify vertical starting angle. Expects a `Float`. Default `0`
+     * @param thetaLength Specify vertical sweep angle size. Expects a `Float`. Default `Math.PI`
      */
     constructor(
         radius?: number,
@@ -27,19 +42,26 @@ export class SphereGeometry extends BufferGeometry {
     );
 
     /**
-     * @default 'SphereGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `SphereGeometry`
      */
-    type: string;
+    override readonly type: string | 'SphereGeometry';
 
-    parameters: {
-        radius: number;
-        widthSegments: number;
-        heightSegments: number;
-        phiStart: number;
-        phiLength: number;
-        thetaStart: number;
-        thetaLength: number;
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly radius: number;
+        readonly widthSegments: number;
+        readonly heightSegments: number;
+        readonly phiStart: number;
+        readonly phiLength: number;
+        readonly thetaStart: number;
+        readonly thetaLength: number;
     };
 
-    static fromJSON(data: any): SphereGeometry;
+    /** @internal */
+    static fromJSON(data: {}): SphereGeometry;
 }

three/src/geometries/TetrahedronGeometry.d.ts

@@ -1,16 +1,25 @@
 import { PolyhedronGeometry } from './PolyhedronGeometry';
 
+/**
+ * A class for generating a tetrahedron geometries.
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/TetrahedronGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/TetrahedronGeometry.js | Source}
+ */
 export class TetrahedronGeometry extends PolyhedronGeometry {
     /**
-     * @param [radius=1]
-     * @param [detail=0]
+     * Create a new instance of {@link TetrahedronGeometry}
+     * @param radius Radius of the tetrahedron. Expects a `Float`. Default `1`
+     * @param detail Setting this to a value greater than 0 adds vertices making it no longer a tetrahedron. Expects a `Integer`. Default `0`
      */
     constructor(radius?: number, detail?: number);
 
     /**
-     * @default 'TetrahedronGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `TetrahedronGeometry`
      */
-    type: string;
+    override readonly type: string | 'TetrahedronGeometry';
 
-    static fromJSON(data: any): TetrahedronGeometry;
+    /** @internal */
+    static fromJSON(data: {}): TetrahedronGeometry;
 }

three/src/geometries/TorusGeometry.d.ts

@@ -1,27 +1,49 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * A class for generating torus geometries.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.TorusGeometry(10, 3, 16, 100);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const torus = new THREE.Mesh(geometry, material);
+ * scene.add(torus);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/TorusGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/TorusGeometry.js | Source}
+ */
 export class TorusGeometry extends BufferGeometry {
     /**
-     * @param radius - Radius of the torus, from the center of the torus to the center of the tube. Default is 1.
-     * @param tube - Radius of the tube. Default is 0.4.
-     * @param radialSegments - Default is 12
-     * @param tubularSegments - Default is 48.
-     * @param arc - Central angle. Default is Math.PI * 2.
+     * Create a new instance of {@link TorusGeometry}
+     * @param radius Radius of the torus, from the center of the torus to the center of the tube. Expects a `Float`. Default `1`.
+     * @param tube Radius of the tube. Expects a `Float`. Default `0.4`.
+     * @param radialSegments Expects a `Integer`.Default is `12`.
+     * @param tubularSegments Expects a `Integer`. Default `48`.
+     * @param arc Central angle. Expects a `Float`. Default `Math.PI * 2`
      */
     constructor(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, arc?: number);
 
     /**
-     * @default 'TorusGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `TorusGeometry`
      */
-    type: string;
+    override readonly type: string | 'TorusGeometry';
 
-    parameters: {
-        radius: number;
-        tube: number;
-        radialSegments: number;
-        tubularSegments: number;
-        arc: number;
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly radius: number;
+        readonly tube: number;
+        readonly radialSegments: number;
+        readonly tubularSegments: number;
+        readonly arc: number;
     };
 
+    /** @internal */
     static fromJSON(data: any): TorusGeometry;
 }

three/src/geometries/TorusKnotGeometry.d.ts

@@ -1,13 +1,29 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * Creates a torus knot, the particular shape of which is defined by a pair of coprime integers, p and q
+ * If p and q are not coprime, the result will be a torus link.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.TorusKnotGeometry(10, 3, 100, 16);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const torusKnot = new THREE.Mesh(geometry, material);
+ * scene.add(torusKnot);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/TorusKnotGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/TorusKnotGeometry.js | Source}
+ */
 export class TorusKnotGeometry extends BufferGeometry {
     /**
-     * @param [radius=1]
-     * @param [tube=0.4]
-     * @param [radialSegments=64]
-     * @param [tubularSegments=8]
-     * @param [p=2]
-     * @param [q=3]
+     * Create a new instance of {@link TorusKnotGeometry}
+     * @param radius Radius of the torus.. Default `1`.
+     * @param tube Expects a `Float`. Default `0.4`.
+     * @param tubularSegments Expects a `Integer`. Default `64`.
+     * @param radialSegments Expects a `Integer`. Default `8`.
+     * @param p This value determines, how many times the geometry winds around its axis of rotational symmetry. Expects a `Integer`. Default `2`.
+     * @param q This value determines, how many times the geometry winds around a circle in the interior of the torus. Expects a `Integer`. Default `3`.
      */
     constructor(
         radius?: number,
@@ -19,18 +35,25 @@ export class TorusKnotGeometry extends BufferGeometry {
     );
 
     /**
-     * @default 'TorusKnotGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `TorusKnotGeometry`
      */
-    type: string;
+    override readonly type: string | 'TorusKnotGeometry';
 
-    parameters: {
-        radius: number;
-        tube: number;
-        tubularSegments: number;
-        radialSegments: number;
-        p: number;
-        q: number;
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly radius: number;
+        readonly tube: number;
+        readonly tubularSegments: number;
+        readonly radialSegments: number;
+        readonly p: number;
+        readonly q: number;
     };
 
-    static fromJSON(data: any): TorusKnotGeometry;
+    /** @internal */
+    static fromJSON(data: {}): TorusKnotGeometry;
 }

three/src/geometries/TubeGeometry.d.ts

@@ -2,37 +2,85 @@ import { Curve } from './../extras/core/Curve';
 import { Vector3 } from './../math/Vector3';
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * Creates a tube that extrudes along a 3d curve.
+ * @example
+ * ```typescript
+ * class CustomSinCurve extends THREE.Curve {
+ *     constructor(scale = 1) {
+ *         super();
+ *         this.scale = scale;
+ *     }
+ *     getPoint(t, optionalTarget = new THREE.Vector3()) {
+ *         const tx = t * 3 - 1.5;
+ *         const ty = Math.sin(2 * Math.PI * t);
+ *         const tz = 0;
+ *         return optionalTarget.set(tx, ty, tz).multiplyScalar(this.scale);
+ *     }
+ * }
+ * const path = new CustomSinCurve(10);
+ * const geometry = new THREE.TubeGeometry(path, 20, 2, 8, false);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0x00ff00
+ * });
+ * const mesh = new THREE.Mesh(geometry, material);
+ * scene.add(mesh);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/TubeGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/TubeGeometry.js | Source}
+ */
 export class TubeGeometry extends BufferGeometry {
     /**
-     * @param path
-     * @param [tubularSegments=64]
-     * @param [radius=1]
-     * @param [radiusSegments=8]
-     * @param [closed=false]
+     * Create a new instance of {@link TubeGeometry}
+     * @param path A 3D path that inherits from the {@link THREE.Curve | Curve} base class.
+     *             Default {@link THREE.QuadraticBezierCurve3 | new THREE.QuadraticBezierCurve3(new Vector3(-1, -1, 0 ), new Vector3(-1, 1, 0), new Vector3(1, 1, 0))}.
+     * @param tubularSegments The number of segments that make up the tube. Expects a `Integer`. Default `64`.
+     * @param radius The radius of the tube. Expects a `Float`. Default `1`.
+     * @param radialSegments The number of segments that make up the cross-section. Expects a `Integer`. Default `8`.
+     * @param closed Is the tube open or closed. Default `false`.
      */
     constructor(
         path?: Curve<Vector3>,
         tubularSegments?: number,
         radius?: number,
-        radiusSegments?: number,
+        radialSegments?: number,
         closed?: boolean,
     );
 
     /**
-     * @default 'TubeGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `TubeGeometry`
      */
-    type: string;
+    override readonly type: string | 'TubeGeometry';
 
-    parameters: {
-        path: Curve<Vector3>;
-        tubularSegments: number;
-        radius: number;
-        radialSegments: number;
-        closed: boolean;
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly path: Curve<Vector3>;
+        readonly tubularSegments: number;
+        readonly radius: number;
+        readonly radialSegments: number;
+        readonly closed: boolean;
     };
+
+    /**
+     * An array of {@link THREE.Vector3 | Vector3} tangents
+     */
     tangents: Vector3[];
+
+    /**
+     * An array of {@link THREE.Vector3 | Vector3} normals
+     */
     normals: Vector3[];
+
+    /**
+     * An array of {@link THREE.Vector3 | Vector3} binormals
+     */
     binormals: Vector3[];
 
-    static fromJSON(data: any): TubeGeometry;
+    /** @internal */
+    static fromJSON(data: {}): TubeGeometry;
 }

three/src/geometries/WireframeGeometry.d.ts

@@ -1,14 +1,40 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * This can be used as a helper object to view a {@link BufferGeometry | geometry} as a wireframe.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.SphereGeometry(100, 100, 100);
+ * const wireframe = new THREE.WireframeGeometry(geometry);
+ * const line = new THREE.LineSegments(wireframe);
+ * line.material.depthTest = false;
+ * line.material.opacity = 0.25;
+ * line.material.transparent = true;
+ * scene.add(line);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_helpers | helpers}
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/WireframeGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/WireframeGeometry.js | Source}
+ */
 export class WireframeGeometry<TBufferGeometry extends BufferGeometry = BufferGeometry> extends BufferGeometry {
+    /**
+     * Create a new instance of {@link WireframeGeometry}
+     * @param geometry Any geometry object. Default `null`.
+     */
     constructor(geometry?: TBufferGeometry);
 
     /**
-     * @default 'WireframeGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `WireframeGeometry`
      */
-    type: string;
+    override readonly type: string | 'WireframeGeometry';
 
-    parameters: {
-        geometry: TBufferGeometry;
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly geometry: TBufferGeometry;
     };
 }

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -16,10 +16,16 @@ export interface MeshPhysicalMaterialParameters extends MeshStandardMaterialPara
 
     sheen?: number | undefined;
     sheenColor?: Color | undefined;
+    sheenColorMap?: Texture | null | undefined;
     sheenRoughness?: number | undefined;
+    sheenRoughnessMap?: Texture | null | undefined;
 
     transmission?: number | undefined;
     transmissionMap?: Texture | null | undefined;
+
+    thickness?: number | undefined;
+    thicknessMap?: Texture | null | undefined;
+
     attenuationDistance?: number | undefined;
     attenuationColor?: Color | undefined;
 
@@ -27,6 +33,12 @@ export interface MeshPhysicalMaterialParameters extends MeshStandardMaterialPara
     specularColor?: Color | undefined;
     specularIntensityMap?: Texture | null | undefined;
     specularColorMap?: Texture | null | undefined;
+
+    iridescenceMap?: Texture | null | undefined;
+    iridescenceIOR?: number | undefined;
+    iridescence?: number | undefined;
+    iridescenceThicknessRange?: [number, number] | undefined;
+    iridescenceThicknessMap?: Texture | null | undefined;
 }
 
 export class MeshPhysicalMaterial extends MeshStandardMaterial {
@@ -175,7 +187,7 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
     /**
      * @default [100, 400]
      */
-    iridescenceThicknessRange: number[];
+    iridescenceThicknessRange: [number, number];
 
     /**
      * @default null

three/src/math/Color.d.ts

@@ -2,9 +2,163 @@ import { ColorSpace } from '../constants';
 import { ColorRepresentation } from '../utils';
 
 import { BufferAttribute } from './../core/BufferAttribute';
+import { InterleavedBufferAttribute } from './../core/InterleavedBufferAttribute';
 
 export { SRGBToLinear } from './ColorManagement';
 
+declare const _colorKeywords: {
+    aliceblue: 0xf0f8ff;
+    antiquewhite: 0xfaebd7;
+    aqua: 0x00ffff;
+    aquamarine: 0x7fffd4;
+    azure: 0xf0ffff;
+    beige: 0xf5f5dc;
+    bisque: 0xffe4c4;
+    black: 0x000000;
+    blanchedalmond: 0xffebcd;
+    blue: 0x0000ff;
+    blueviolet: 0x8a2be2;
+    brown: 0xa52a2a;
+    burlywood: 0xdeb887;
+    cadetblue: 0x5f9ea0;
+    chartreuse: 0x7fff00;
+    chocolate: 0xd2691e;
+    coral: 0xff7f50;
+    cornflowerblue: 0x6495ed;
+    cornsilk: 0xfff8dc;
+    crimson: 0xdc143c;
+    cyan: 0x00ffff;
+    darkblue: 0x00008b;
+    darkcyan: 0x008b8b;
+    darkgoldenrod: 0xb8860b;
+    darkgray: 0xa9a9a9;
+    darkgreen: 0x006400;
+    darkgrey: 0xa9a9a9;
+    darkkhaki: 0xbdb76b;
+    darkmagenta: 0x8b008b;
+    darkolivegreen: 0x556b2f;
+    darkorange: 0xff8c00;
+    darkorchid: 0x9932cc;
+    darkred: 0x8b0000;
+    darksalmon: 0xe9967a;
+    darkseagreen: 0x8fbc8f;
+    darkslateblue: 0x483d8b;
+    darkslategray: 0x2f4f4f;
+    darkslategrey: 0x2f4f4f;
+    darkturquoise: 0x00ced1;
+    darkviolet: 0x9400d3;
+    deeppink: 0xff1493;
+    deepskyblue: 0x00bfff;
+    dimgray: 0x696969;
+    dimgrey: 0x696969;
+    dodgerblue: 0x1e90ff;
+    firebrick: 0xb22222;
+    floralwhite: 0xfffaf0;
+    forestgreen: 0x228b22;
+    fuchsia: 0xff00ff;
+    gainsboro: 0xdcdcdc;
+    ghostwhite: 0xf8f8ff;
+    gold: 0xffd700;
+    goldenrod: 0xdaa520;
+    gray: 0x808080;
+    green: 0x008000;
+    greenyellow: 0xadff2f;
+    grey: 0x808080;
+    honeydew: 0xf0fff0;
+    hotpink: 0xff69b4;
+    indianred: 0xcd5c5c;
+    indigo: 0x4b0082;
+    ivory: 0xfffff0;
+    khaki: 0xf0e68c;
+    lavender: 0xe6e6fa;
+    lavenderblush: 0xfff0f5;
+    lawngreen: 0x7cfc00;
+    lemonchiffon: 0xfffacd;
+    lightblue: 0xadd8e6;
+    lightcoral: 0xf08080;
+    lightcyan: 0xe0ffff;
+    lightgoldenrodyellow: 0xfafad2;
+    lightgray: 0xd3d3d3;
+    lightgreen: 0x90ee90;
+    lightgrey: 0xd3d3d3;
+    lightpink: 0xffb6c1;
+    lightsalmon: 0xffa07a;
+    lightseagreen: 0x20b2aa;
+    lightskyblue: 0x87cefa;
+    lightslategray: 0x778899;
+    lightslategrey: 0x778899;
+    lightsteelblue: 0xb0c4de;
+    lightyellow: 0xffffe0;
+    lime: 0x00ff00;
+    limegreen: 0x32cd32;
+    linen: 0xfaf0e6;
+    magenta: 0xff00ff;
+    maroon: 0x800000;
+    mediumaquamarine: 0x66cdaa;
+    mediumblue: 0x0000cd;
+    mediumorchid: 0xba55d3;
+    mediumpurple: 0x9370db;
+    mediumseagreen: 0x3cb371;
+    mediumslateblue: 0x7b68ee;
+    mediumspringgreen: 0x00fa9a;
+    mediumturquoise: 0x48d1cc;
+    mediumvioletred: 0xc71585;
+    midnightblue: 0x191970;
+    mintcream: 0xf5fffa;
+    mistyrose: 0xffe4e1;
+    moccasin: 0xffe4b5;
+    navajowhite: 0xffdead;
+    navy: 0x000080;
+    oldlace: 0xfdf5e6;
+    olive: 0x808000;
+    olivedrab: 0x6b8e23;
+    orange: 0xffa500;
+    orangered: 0xff4500;
+    orchid: 0xda70d6;
+    palegoldenrod: 0xeee8aa;
+    palegreen: 0x98fb98;
+    paleturquoise: 0xafeeee;
+    palevioletred: 0xdb7093;
+    papayawhip: 0xffefd5;
+    peachpuff: 0xffdab9;
+    peru: 0xcd853f;
+    pink: 0xffc0cb;
+    plum: 0xdda0dd;
+    powderblue: 0xb0e0e6;
+    purple: 0x800080;
+    rebeccapurple: 0x663399;
+    red: 0xff0000;
+    rosybrown: 0xbc8f8f;
+    royalblue: 0x4169e1;
+    saddlebrown: 0x8b4513;
+    salmon: 0xfa8072;
+    sandybrown: 0xf4a460;
+    seagreen: 0x2e8b57;
+    seashell: 0xfff5ee;
+    sienna: 0xa0522d;
+    silver: 0xc0c0c0;
+    skyblue: 0x87ceeb;
+    slateblue: 0x6a5acd;
+    slategray: 0x708090;
+    slategrey: 0x708090;
+    snow: 0xfffafa;
+    springgreen: 0x00ff7f;
+    steelblue: 0x4682b4;
+    tan: 0xd2b48c;
+    teal: 0x008080;
+    thistle: 0xd8bfd8;
+    tomato: 0xff6347;
+    turquoise: 0x40e0d0;
+    violet: 0xee82ee;
+    wheat: 0xf5deb3;
+    white: 0xffffff;
+    whitesmoke: 0xf5f5f5;
+    yellow: 0xffff00;
+    yellowgreen: 0x9acd32;
+};
+
+export type ColorKeyword = keyof typeof _colorKeywords;
+
 export interface HSL {
     h: number;
     s: number;
@@ -82,7 +236,7 @@ export class Color {
      * Faster than {@link Color#setStyle .setStyle()} method if you don't need the other CSS-style formats.
      * @param style Color name in X11 format.
      */
-    setColorName(style: string, colorSpace?: ColorSpace): Color;
+    setColorName(style: ColorKeyword, colorSpace?: ColorSpace): Color;
 
     /**
      * Clones this color.
@@ -173,12 +327,12 @@ export class Color {
      */
     toArray(xyz: ArrayLike<number>, offset?: number): ArrayLike<number>;
 
-    fromBufferAttribute(attribute: BufferAttribute, index: number): this;
+    fromBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, index: number): this;
 
     [Symbol.iterator](): Generator<number, void>;
 
     /**
      * List of X11 color names.
      */
-    static NAMES: Record<string, number>;
+    static NAMES: typeof _colorKeywords;
 }

three/src/math/ColorManagement.d.ts

@@ -1,4 +1,4 @@
-import { ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from '../constants';
+import { ColorSpace, DisplayP3ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from '../constants';
 import { Color } from './Color';
 
 export function SRGBToLinear(c: number): number;
@@ -7,9 +7,9 @@ export function LinearToSRGB(c: number): number;
 
 export namespace ColorManagement {
     /**
-     * @default true
+     * @default false
      */
-    let legacyMode: boolean;
+    let enabled: boolean;
 
     /**
      * @default LinearSRGBColorSpace
@@ -18,11 +18,17 @@ export namespace ColorManagement {
 
     function convert(
         color: Color,
-        sourceColorSpace: SRGBColorSpace | LinearSRGBColorSpace,
-        targetColorSpace: SRGBColorSpace | LinearSRGBColorSpace,
+        sourceColorSpace: typeof SRGBColorSpace | typeof LinearSRGBColorSpace | typeof DisplayP3ColorSpace,
+        targetColorSpace: typeof SRGBColorSpace | typeof LinearSRGBColorSpace | typeof DisplayP3ColorSpace,
     ): Color;
 
-    function fromWorkingColorSpace(color: Color, targetColorSpace: SRGBColorSpace | LinearSRGBColorSpace): Color;
+    function fromWorkingColorSpace(
+        color: Color,
+        targetColorSpace: typeof SRGBColorSpace | typeof LinearSRGBColorSpace | typeof DisplayP3ColorSpace,
+    ): Color;
 
-    function toWorkingColorSpace(color: Color, sourceColorSpace: SRGBColorSpace | LinearSRGBColorSpace): Color;
+    function toWorkingColorSpace(
+        color: Color,
+        sourceColorSpace: typeof SRGBColorSpace | typeof LinearSRGBColorSpace | typeof DisplayP3ColorSpace,
+    ): Color;
 }