@types/three 0.149.0 → 0.150.0

three/src/core/Raycaster.d.ts

@@ -14,15 +14,21 @@ export interface Face {
 }
 
 export interface Intersection<TIntersected extends Object3D = Object3D> {
+    /** Distance between the origin of the ray and the intersection */
     distance: number;
     distanceToRay?: number | undefined;
+    /** Point of intersection, in world coordinates */
     point: Vector3;
     index?: number | undefined;
+    /** Intersected face */
     face?: Face | null | undefined;
+    /** Index of the intersected face */
     faceIndex?: number | undefined;
+    /** The intersected object */
     object: TIntersected;
     uv?: Vector2 | undefined;
     uv2?: Vector2 | undefined;
+    /** The index number of the instance where the ray intersects the {@link THREE.InstancedMesh | InstancedMesh } */
     instanceId?: number | undefined;
 }
 
@@ -34,52 +40,105 @@ export interface RaycasterParameters {
     Sprite?: any;
 }
 
+/**
+ * This class is designed to assist with {@link https://en.wikipedia.org/wiki/Ray_casting | raycasting}
+ * @remarks
+ * Raycasting is used for mouse picking (working out what objects in the 3d space the mouse is over) amongst other things.
+ * @example
+ * ```typescript
+ * const raycaster = new THREE.Raycaster();
+ * const pointer = new THREE.Vector2();
+ *
+ * function onPointerMove(event) {
+ *     // calculate pointer position in normalized device coordinates (-1 to +1) for both components
+ *     pointer.x = (event.clientX / window.innerWidth) * 2 - 1;
+ *     pointer.y = -(event.clientY / window.innerHeight) * 2 + 1;
+ * }
+ *
+ * function render() {
+ *     // update the picking ray with the camera and pointer position
+ *     raycaster.setFromCamera(pointer, camera);
+ *     // calculate objects intersecting the picking ray
+ *     const intersects = raycaster.intersectObjects(scene.children);
+ *     for (let i = 0; i & lt; intersects.length; i++) {
+ *         intersects[i].object.material.color.set(0xff0000);
+ *     }
+ *     renderer.render(scene, camera);
+ * }
+ * window.addEventListener('pointermove', onPointerMove);
+ * window.requestAnimationFrame(render);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_cubes | Raycasting to a Mesh}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_cubes_ortho | Raycasting to a Mesh in using an OrthographicCamera}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_buffergeometry | Raycasting to a Mesh with BufferGeometry}
+ * @see Example: {@link https://threejs.org/examples/#webgl_instancing_raycast | Raycasting to a InstancedMesh}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_lines | Raycasting to a Line}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_raycasting_points | Raycasting to Points}
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_terrain_raycast | Terrain raycasting}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_voxelpainter | Raycasting to paint voxels}
+ * @see Example: {@link https://threejs.org/examples/#webgl_raycaster_texture | Raycast to a Texture}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/Raycaster | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Raycaster.js | Source}
+ */
 export class Raycaster {
     /**
-     * This creates a new raycaster object.
-     * @param origin The origin vector where the ray casts from.
-     * @param direction The direction vector that gives direction to the ray. Should be normalized.
-     * @param near All results returned are further away than near. Near can't be negative. Default value is 0.
-     * @param far All results returned are closer then far. Far can't be lower then near . Default value is Infinity.
+     * This creates a new {@link Raycaster} object.
+     * @param origin The origin vector where the ray casts from. Default `new Vector3()`
+     * @param direction The direction vector that gives direction to the ray. Should be normalized. Default `new Vector3(0, 0, -1)`
+     * @param near All results returned are further away than near. Near can't be negative. Expects a `Float`. Default `0`
+     * @param far All results returned are closer than far. Far can't be lower than near. Expects a `Float`. Default `Infinity`
      */
     constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number);
 
-    /** The Ray used for the raycasting. */
+    /**
+     * The {@link THREE.RaycasterRay | Ray} used for the raycasting.
+     */
     ray: Ray;
 
     /**
-     * The near factor of the raycaster. This value indicates which objects can be discarded based on the
-     * distance. This value shouldn't be negative and should be smaller than the far property.
-     * @default 0
+     * The near factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+     * This value shouldn't be negative and should be smaller than the far property.
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
      */
     near: number;
 
     /**
-     * The far factor of the raycaster. This value indicates which objects can be discarded based on the
-     * distance. This value shouldn't be negative and should be larger than the near property.
-     * @default Infinity
+     * The far factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+     * This value shouldn't be negative and should be larger than the near property.
+     * @remarks Expects a `Float`
+     * @defaultValue `Infinity`
      */
     far: number;
 
     /**
-     * The camera to use when raycasting against view-dependent objects such as billboarded objects like Sprites. This field
-     * can be set manually or is set when calling "setFromCamera".
+     * The camera to use when raycasting against view-dependent objects such as billboarded objects like {@link THREE.Sprites | Sprites}.
+     * This field can be set manually or is set when calling  {@link setFromCamera}.
+     * @defaultValue `null`
      */
     camera: Camera;
 
     /**
-     * Used by Raycaster to selectively ignore 3D objects when performing intersection tests.
-     * @default new THREE.Layers()
+     * Used by {@link Raycaster} to selectively ignore 3D objects when performing intersection tests.
+     * The following code example ensures that only 3D objects on layer `1` will be honored by the instance of Raycaster.
+     * ```
+     * raycaster.layers.set( 1 );
+     * object.layers.enable( 1 );
+     * ```
+     * @defaultValue `new THREE.Layers()` - See {@link THREE.Layers | Layers}.
      */
     layers: Layers;
 
     /**
-     * @default { Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }
+     * An data object where threshold is the precision of the {@link Raycaster} when intersecting objects, in world units.
+     * @defaultValue `{ Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }`
      */
     params: RaycasterParameters;
 
     /**
-     * Updates the ray with a new origin and direction.
+     * Updates the ray with a new origin and direction
+     * @remarks
+     * Please note that this method only copies the values from the arguments.
      * @param origin The origin vector where the ray casts from.
      * @param direction The normalized direction vector that gives direction to the ray.
      */
@@ -90,13 +149,22 @@ export class Raycaster {
      * @param coords 2D coordinates of the mouse, in normalized device coordinates (NDC)---X and Y components should be between -1 and 1.
      * @param camera camera from which the ray should originate
      */
-    setFromCamera(coords: { x: number; y: number }, camera: Camera): void;
+    setFromCamera(coords: Vector2, camera: Camera): void;
 
     /**
-     * Checks all intersection between the ray and the object with or without the descendants. Intersections are returned sorted by distance, closest first.
+     * Checks all intersection between the ray and the object with or without the descendants
+     * @remarks Intersections are returned sorted by distance, closest first
+     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+     * intersections of the ray passing through the back of a face will not be detected
+     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+     * @see {@link intersectObjects | .intersectObjects()}.
      * @param object The object to check for intersection with the ray.
-     * @param recursive If true, it also checks all descendants. Otherwise it only checks intersecton with the object. Default is true.
-     * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
+     * @param recursive If true, it also checks all descendants. Otherwise it only checks intersection with the object. Default `true`
+     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+     * @returns An array of intersections is returned.
      */
     intersectObject<TIntersected extends Object3D>(
         object: Object3D,
@@ -105,12 +173,20 @@ export class Raycaster {
     ): Array<Intersection<TIntersected>>;
 
     /**
-     * Checks all intersection between the ray and the objects with or without the descendants.
-     * Intersections are returned sorted by distance, closest first.
-     * Intersections are of the same form as those returned by .intersectObject.
+     * Checks all intersection between the ray and the objects with or without the descendants
+     * @remarks Intersections are returned sorted by distance, closest first
+     * @remarks Intersections are of the same form as those returned by {@link intersectObject | .intersectObject()}.
+     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+     * intersections of the ray passing through the back of a face will not be detected
+     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+     * @see {@link intersectObject | .intersectObject()}.
      * @param objects The objects to check for intersection with the ray.
-     * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersecton with the objects. Default is true.
-     * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
+     * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersection with the objects. Default `true`
+     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+     * @returns An array of intersections is returned.
      */
     intersectObjects<TIntersected extends Object3D>(
         objects: Object3D[],

three/src/core/Uniform.d.ts

@@ -1,21 +1,38 @@
+/**
+ * Uniforms are global GLSL variables.
+ * They are passed to shader programs.
+ * @example
+ * When declaring a uniform of a {@link THREE.ShaderMaterial | ShaderMaterial}, it is declared by value or by object.
+ * ```typescript
+ * uniforms: {
+ *     time: {
+ *         value: 1.0
+ *     },
+ *     resolution: new Uniform(new Vector2())
+ * };
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_nodes_materials_instance_uniform | WebGL2 / nodes / materials / instance / uniform}
+ * @see Example: {@link https://threejs.org/examples/#webgpu_instance_uniform| WebGPU / instance / uniform}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/Uniform | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Uniform.js | Source}
+ */
 export class Uniform<T = any> {
-    constructor(value: T);
     /**
-     * @deprecated
+     * Create a new instance of {@link THREE.Uniform | Uniform}
+     * @param value An object containing the value to set up the uniform. It's type must be one of the Uniform Types described above.
      */
-    constructor(type: string, value: T);
+    constructor(value: T);
+
     /**
-     * @deprecated
+     * Current value of the uniform.
      */
-    type: string;
     value: T;
-    /**
-     * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
-     */
-    dynamic: boolean;
 
     /**
-     * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
+     * Returns a clone of this uniform.
+     * @remarks
+     * If the uniform's {@link value} property is an {@link Object | Object} with a `clone()` method, this is used,
+     * otherwise the value is copied by assignment Array values are **shared** between cloned {@link THREE.UniformUniform | Uniform}s.
      */
-    onUpdate(callback: () => void): Uniform<T>;
+    clone(): Uniform<T>;
 }

three/src/core/UniformsGroup.d.ts

@@ -1,15 +1,21 @@
 import { EventDispatcher } from './EventDispatcher';
 import { Uniform } from './Uniform';
-
 import { Usage } from '../constants';
 
+/**
+ * @see Example: {@link https://threejs.org/examples/#webgl2_ubo | WebGL2 / UBO}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/UniformsGroup.js | Source}
+ */
 export class UniformsGroup extends EventDispatcher {
-    isUniformsGroup: true;
+    constructor();
+
+    readonly isUniformsGroup: true;
+
     id: number;
+
     usage: Usage;
-    uniforms: Uniform[];
 
-    constructor();
+    uniforms: Uniform[];
 
     add(uniform: Uniform): this;
 

three/src/extras/Earcut.d.ts

@@ -1,4 +1,3 @@
-import { Triangle } from '../Three';
-export namespace Earcut {
-    function triangulate(data: number[], holeIndices: number[], dim: number): Triangle[];
-}
+export const Earcut: {
+    triangulate(data: number[], holeIndices?: number[], dim?: number): number[];
+};

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,
+    ): Color;
 
-    function toWorkingColorSpace(color: Color, sourceColorSpace: SRGBColorSpace | LinearSRGBColorSpace): Color;
+    function toWorkingColorSpace(
+        color: Color,
+        sourceColorSpace: typeof SRGBColorSpace | typeof LinearSRGBColorSpace,
+    ): Color;
 }

three/src/renderers/WebGLRenderer.d.ts

@@ -178,9 +178,9 @@ export class WebGLRenderer implements Renderer {
     outputEncoding: TextureEncoding;
 
     /**
-     * @default false
+     * @default true
      */
-    physicallyCorrectLights: boolean;
+    useLegacyLights: boolean;
 
     /**
      * @default THREE.NoToneMapping

three/src/utils.d.ts

@@ -1,3 +1,6 @@
-import { Color } from './math/Color';
+import { Color, ColorKeyword } from './math/Color';
 
-export type ColorRepresentation = Color | string | number;
+export type ColorModelString = `${'rgb' | 'hsl'}(${string})`;
+export type HexColorString = `#${string}`;
+
+export type ColorRepresentation = Color | ColorKeyword | ColorModelString | HexColorString | number;