@types/three 0.181.0 → 0.183.0

three/src/helpers/SkeletonHelper.d.ts

@@ -1,73 +1,49 @@
 import { Object3D } from "../core/Object3D.js";
 import { Color } from "../math/Color.js";
-import { Matrix4 } from "../math/Matrix4.js";
 import { Bone } from "../objects/Bone.js";
 import { LineSegments } from "../objects/LineSegments.js";
-import { SkinnedMesh } from "../objects/SkinnedMesh.js";
 
 /**
- * A helper object to assist with visualizing a {@link Skeleton | Skeleton}
- * @remarks
- * The helper is rendered using a {@link LineBasicMaterial | LineBasicMaterial}.
- * @example
- * ```typescript
- * const helper = new THREE.SkeletonHelper(skinnedMesh);
- * scene.add(helper);
+ * A helper object to assist with visualizing a {@link Skeleton}.
+ *
+ * ```js
+ * const helper = new THREE.SkeletonHelper( skinnedMesh );
+ * scene.add( helper );
  * ```
- * @see Example: {@link https://threejs.org/examples/#webgl_animation_skinning_blending | WebGL / animation / skinning / blending}
- * @see Example: {@link https://threejs.org/examples/#webgl_animation_skinning_morph | WebGL / animation / skinning / morph}
- * @see Example: {@link https://threejs.org/examples/#webgl_loader_bvh | WebGL / loader / bvh }
- * @see {@link https://threejs.org/docs/index.html#api/en/helpers/SkeletonHelper | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/helpers/SkeletonHelper.js | Source}
  */
-declare class SkeletonHelper extends LineSegments {
+export class SkeletonHelper extends LineSegments {
     /**
-     * Create a new instance of {@link SkeletonHelper}
-     * @param object Usually an instance of {@link THREE.SkinnedMesh | SkinnedMesh}.
-     * However, any instance of {@link THREE.Object3D | Object3D} can be used if it represents a hierarchy of {@link Bone | Bone}s (via {@link THREE.Object3D.children | Object3D.children}).
+     * Constructs a new skeleton helper.
+     *
+     * @param {Object3D} object -  Usually an instance of {@link SkinnedMesh}. However, any 3D object
+     * can be used if it represents a hierarchy of bones (see {@link Bone}).
      */
-    constructor(object: SkinnedMesh | Object3D);
-
+    constructor(object: Object3D);
     /**
-     * Read-only flag to check if a given object is of type {@link SkeletonHelper}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    readonly isSkeletonHelper = true;
-
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @override
-     * @defaultValue `SkeletonHelper`
-     */
-    override readonly type: string | "SkeletonHelper";
-
+    readonly isSkeletonHelper: boolean;
     /**
-     * The object passed in the constructor.
+     * The object being visualized.
      */
-    root: SkinnedMesh | Object3D;
-
+    root: Object3D;
     /**
-     * The list of bones that the helper renders as {@link Line | Lines}.
+     * The list of bones that the helper visualizes.
      */
     bones: Bone[];
-
     /**
-     * Is set to `false`, as the helper is using the {@link THREE.Object3D.matrixWorld | root.matrixWorld}.
-     * @see {@link THREE.Object3D.matrixAutoUpdate | Object3D.matrixAutoUpdate}.
-     * @defaultValue `false`.
+     * Defines the colors of the helper.
+     *
+     * @param {Color} color1 - The first line color for each bone.
+     * @param {Color} color2 - The second line color for each bone.
+     * @return {SkeletonHelper} A reference to this helper.
      */
-    override matrixAutoUpdate: boolean;
-
-    setColors(color1: Color, color2: Color): this;
-
+    setColors(color1: Color, color2: Color): SkeletonHelper;
     /**
-     * Frees the GPU-related resources allocated by this instance
-     * @remarks
-     * Call this method whenever this instance is no longer used in your app.
+     * Frees the GPU-related resources allocated by this instance. Call this
+     * method whenever this instance is no longer used in your app.
      */
     dispose(): void;
 }
-
-export { SkeletonHelper };

three/src/helpers/SpotLightHelper.d.ts

@@ -1,77 +1,50 @@
 import { Object3D } from "../core/Object3D.js";
-import { Light } from "../lights/Light.js";
+import { SpotLight } from "../lights/SpotLight.js";
 import { ColorRepresentation } from "../math/Color.js";
-import { Matrix4 } from "../math/Matrix4.js";
 import { LineSegments } from "../objects/LineSegments.js";
 
 /**
- * This displays a cone shaped helper object for a {@link THREE.SpotLight | SpotLight}.
- * @example
- * ```typescript
- * const spotLight = new THREE.SpotLight(0xffffff);
- * spotLight.position.set(10, 10, 10);
- * scene.add(spotLight);
- * const {@link SpotLightHelper} = new THREE.SpotLightHelper(spotLight);
- * scene.add(spotLightHelper);
+ * This displays a cone shaped helper object for a {@link SpotLight}.
+ *
+ * When the spot light or its target are transformed or light properties are
+ * changed, it's necessary to call the `update()` method of the respective helper.
+ *
+ * ```js
+ * const spotLight = new THREE.SpotLight( 0xffffff );
+ * spotLight.position.set( 10, 10, 10 );
+ * scene.add( spotLight );
+ *
+ * const spotLightHelper = new THREE.SpotLightHelper( spotLight );
+ * scene.add( spotLightHelper );
  * ```
- * @see Example: {@link https://threejs.org/examples/#webgl_lights_spotlights | WebGL/ lights / spotlights }
- * @see {@link https://threejs.org/docs/index.html#api/en/helpers/SpotLightHelper | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/helpers/SpotLightHelper.js | Source}
  */
 export class SpotLightHelper extends Object3D {
     /**
-     * Create a new instance of {@link SpotLightHelper}
-     * @param light The {@link THREE.SpotLight | SpotLight} to be visualized.
-     * @param color If this is not the set the helper will take the color of the light. Default `light.color`
+     * Constructs a new spot light helper.
+     *
+     * @param {HemisphereLight} light - The light to be visualized.
+     * @param {number|Color|string} [color] - The helper's color. If not set, the helper will take
+     * the color of the light.
      */
-    constructor(light: Light, color?: ColorRepresentation);
-
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @override
-     * @defaultValue `SpotLightHelper`
-     */
-    override readonly type: string | "SpotLightHelper";
-
-    /**
-     * {@link THREE.LineSegments | LineSegments} used to visualize the light.
-     */
-    cone: LineSegments;
-
-    /**
-     * Reference to the {@link THREE.SpotLight | SpotLight} being visualized.
-     */
-    light: Light;
-
+    constructor(light: SpotLight, color?: ColorRepresentation);
     /**
-     * Reference to the spotLight's {@link Object3D.matrixWorld | matrixWorld}.
+     * The light being visualized.
      */
-    matrix: Matrix4;
-
+    light: SpotLight;
     /**
      * The color parameter passed in the constructor.
-     * If this is changed, the helper's color will update the next time {@link SpotLightHelper.update | update} is called.
-     * @defaultValue `undefined`
+     * If not set, the helper will take the color of the light.
      */
     color: ColorRepresentation | undefined;
-
+    cone: LineSegments;
     /**
-     * Is set to `false`, as the helper is using the {@link THREE.Light.matrixWorld | light.matrixWorld}.
-     * @see {@link THREE.Object3D.matrixAutoUpdate | Object3D.matrixAutoUpdate}.
-     * @defaultValue `false`.
+     * Frees the GPU-related resources allocated by this instance. Call this
+     * method whenever this instance is no longer used in your app.
      */
-    override matrixAutoUpdate: boolean;
-
+    dispose(): void;
     /**
-     * Updates the light helper.
+     * Updates the helper to match the position and direction of the
+     * light being visualized.
      */
     update(): void;
-
-    /**
-     * Frees the GPU-related resources allocated by this instance
-     * @remarks
-     * Call this method whenever this instance is no longer used in your app.
-     */
-    dispose(): void;
 }

three/src/lights/AmbientLight.d.ts

@@ -3,34 +3,26 @@ import { Light } from "./Light.js";
 
 /**
  * This light globally illuminates all objects in the scene equally.
- * @remarks This light cannot be used to cast shadows as it does not have a direction.
- * @example
- * ```typescript
- * const light = new THREE.AmbientLight(0x404040); // soft white light
- * scene.add(light);
+ *
+ * It cannot be used to cast shadows as it does not have a direction.
+ *
+ * ```js
+ * const light = new THREE.AmbientLight( 0x404040 ); // soft white light
+ * scene.add( light );
  * ```
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/AmbientLight | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/AmbientLight.js | Source}
  */
-export class AmbientLight extends Light<undefined> {
+export class AmbientLight extends Light {
     /**
-     * Creates a new {@link AmbientLight}.
-     * @param color Numeric value of the RGB component of the color. Default `0xffffff`
-     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`
+     * Constructs a new ambient light.
+     *
+     * @param {(number|Color|string)} [color=0xffffff] - The light's color.
+     * @param {number} [intensity=1] - The light's strength/intensity.
      */
     constructor(color?: ColorRepresentation, intensity?: number);
-
-    /**
-     * Read-only flag to check if a given object is of type {@link AmbientLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isAmbientLight: true;
-
     /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `AmbientLight`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    override readonly type: string | "AmbientLight";
+    readonly isAmbientLight: boolean;
 }

three/src/lights/DirectionalLight.d.ts

@@ -1,102 +1,68 @@
-import { Object3D } from "../core/Object3D.js";
+import { JSONMeta, Object3D } from "../core/Object3D.js";
 import { ColorRepresentation } from "../math/Color.js";
-import { Vector3 } from "../math/Vector3.js";
 import { DirectionalLightShadow } from "./DirectionalLightShadow.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+import { LightShadowJSON } from "./LightShadow.js";
+
+export interface DirectionalLightJSON extends LightJSON {
+    shadow: LightShadowJSON;
+    target: string;
+}
 
 /**
- * A light that gets emitted in a specific direction
- * @remarks
- * This light will behave as though it is infinitely far away and the rays produced from it are all parallel
- * The common use case for this is to simulate daylight; the sun is far enough away that its position can be considered to be infinite, and all light rays coming from it are parallel.
- * A common point of confusion for directional lights is that setting the rotation has no effect
- * This is because three.js's {@link DirectionalLight} is the equivalent to what is often called a 'Target Direct Light' in other applications.
- * This means that its direction is calculated as pointing from the light's {@link THREE.Object3D.position | position} to the {@link THREE.DirectionalLight.target | target}'s
- * position (as opposed to a 'Free Direct Light' that just has a rotation component).
- * See the {@link THREE.DirectionalLight.target | target} property below for details on updating the target.
- * @example
- * ```typescript
+ * A light that gets emitted in a specific direction. This light will behave
+ * as though it is infinitely far away and the rays produced from it are all
+ * parallel. The common use case for this is to simulate daylight; the sun is
+ * far enough away that its position can be considered to be infinite, and
+ * all light rays coming from it are parallel.
+ *
+ * A common point of confusion for directional lights is that setting the
+ * rotation has no effect. This is because three.js's DirectionalLight is the
+ * equivalent to what is often called a 'Target Direct Light' in other
+ * applications.
+ *
+ * This means that its direction is calculated as pointing from the light's
+ * {@link Object3D#position} to the {@link DirectionalLight#target} position
+ * (as opposed to a 'Free Direct Light' that just has a rotation
+ * component).
+ *
+ * This light can cast shadows - see the {@link DirectionalLightShadow} for details.
+ *
+ * ```js
  * // White directional light at half intensity shining from the top.
- * const {@link DirectionalLight} = new THREE.DirectionalLight(0xffffff, 0.5);
- * scene.add(directionalLight);
+ * const directionalLight = new THREE.DirectionalLight( 0xffffff, 0.5 );
+ * scene.add( directionalLight );
  * ```
- * @see Example: {@link https://threejs.org/examples/#misc_controls_fly | controls / fly }
- * @see Example: {@link https://threejs.org/examples/#webgl_effects_parallaxbarrier | effects / parallaxbarrier }
- * @see Example: {@link https://threejs.org/examples/#webgl_effects_stereo | effects / stereo }
- * @see Example: {@link https://threejs.org/examples/#webgl_geometry_extrude_splines | geometry / extrude / splines }
- * @see Example: {@link https://threejs.org/examples/#webgl_materials_bumpmap | materials / bumpmap }
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/DirectionalLight | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/DirectionalLight.js | Source}
  */
-export class DirectionalLight extends Light<DirectionalLightShadow> {
+export class DirectionalLight extends Light {
     /**
-     * Creates a new {@link DirectionalLight}.
-     * @param color Hexadecimal color of the light. Default `0xffffff` _(white)_.
-     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`
+     * Constructs a new directional light.
+     *
+     * @param {(number|Color|string)} [color=0xffffff] - The light's color.
+     * @param {number} [intensity=1] - The light's strength/intensity.
      */
     constructor(color?: ColorRepresentation, intensity?: number);
-
-    /**
-     * Read-only flag to check if a given object is of type {@link DirectionalLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isDirectionalLight: true;
-
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `DirectionalLight`
-     */
-    override readonly type: string | "DirectionalLight";
-
-    /**
-     * Whether the object gets rendered into shadow map.
-     * @remarks
-     * If set to `true` light will cast dynamic shadows.
-     * **Warning**: This is expensive and requires tweaking to get shadows looking right.
-     * @see {@link THREE.DirectionalLightShadow | DirectionalLightShadow} for details.
-     * @defaultValue `false`
-     */
-    override castShadow: boolean;
-
     /**
-     * This is set equal to {@link THREE.Object3D.DEFAULT_UP}, so that the light shines from the top down.
-     * @defaultValue {@link Object3D.DEFAULT_UP} _(0, 1, 0)_
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    override readonly position: Vector3;
-
+    readonly isDirectionalLight: boolean;
     /**
-     * A {@link THREE.DirectionalLightShadow | DirectionalLightShadow} used to calculate shadows for this light.
-     * @defaultValue `new THREE.DirectionalLightShadow()`
-     */
-    shadow: DirectionalLightShadow;
-
-    /**
-     * The {@link DirectionalLight} points from its {@link DirectionalLight.position | position} to target.position.
-     * @remarks **Note**: For the target's position to be changed to anything other than the default,
-     * it must be added to the {@link THREE.Scene | scene} using
-     * ```typescript
-     * Scene.add( light.target );
-     * ```
-     * This is so that the target's {@link THREE.Object3D.matrixWorld | matrixWorld} gets automatically updated each frame.
+     * The directional light points from its position to the
+     * target's position.
+     *
+     * For the target's position to be changed to anything other
+     * than the default, it must be added to the scene.
      *
-     * It is also possible to set the target to be another object in the scene (anything with a {@link THREE.Object3D.position | position} property),
-     * like so:
-     * ```typescript
-     * const targetObject = new THREE.Object3D();
-     * scene.add(targetObject);
-     * light.target = targetObject;
-     * ```
-     * The {@link DirectionalLight} will now track the target object.
-     * @defaultValue `new THREE.Object3D()` at _(0, 0, 0)_
+     * It is also possible to set the target to be another 3D object
+     * in the scene. The light will now track the target object.
      */
     target: Object3D;
-
     /**
-     * Frees the GPU-related resources allocated by this instance
-     * @remarks
-     * Call this method whenever this instance is no longer used in your app.
+     * This property holds the light's shadow configuration.
      */
-    dispose(): void;
+    shadow: DirectionalLightShadow;
+    copy(source: DirectionalLight): this;
+    toJSON(meta?: JSONMeta): DirectionalLightJSON;
 }

three/src/lights/DirectionalLightShadow.d.ts

@@ -2,72 +2,17 @@ import { OrthographicCamera } from "../cameras/OrthographicCamera.js";
 import { LightShadow } from "./LightShadow.js";
 
 /**
- * This is used internally by {@link DirectionalLight | DirectionalLights} for calculating shadows.
- * Unlike the other shadow classes, this uses an {@link THREE.OrthographicCamera | OrthographicCamera} to calculate the shadows,
- * rather than a {@link THREE.PerspectiveCamera | PerspectiveCamera}
- * @remarks
- * This is because light rays from a {@link THREE.DirectionalLight | DirectionalLight} are parallel.
- * @example
- * ```typescript
- * //Create a WebGLRenderer and turn on shadows in the renderer
- * const renderer = new THREE.WebGLRenderer();
- * renderer.shadowMap.enabled = true;
- * renderer.shadowMap.type = THREE.PCFSoftShadowMap; // default THREE.PCFShadowMap
- * //Create a DirectionalLight and turn on shadows for the light
- * const light = new THREE.DirectionalLight(0xffffff, 1);
- * light.position.set(0, 1, 0); //default; light shining from top
- * light.castShadow = true; // default false
- * scene.add(light);
- * //Set up shadow properties for the light
- * light.shadow.mapSize.width = 512; // default
- * light.shadow.mapSize.height = 512; // default
- * light.shadow.camera.near = 0.5; // default
- * light.shadow.camera.far = 500; // default
- * //Create a sphere that cast shadows (but does not receive them)
- * const sphereGeometry = new THREE.SphereGeometry(5, 32, 32);
- * const sphereMaterial = new THREE.MeshStandardMaterial({
- *     color: 0xff0000
- * });
- * const sphere = new THREE.Mesh(sphereGeometry, sphereMaterial);
- * sphere.castShadow = true; //default is false
- * sphere.receiveShadow = false; //default
- * scene.add(sphere);
- * //Create a plane that receives shadows (but does not cast them)
- * const planeGeometry = new THREE.PlaneGeometry(20, 20, 32, 32);
- * const planeMaterial = new THREE.MeshStandardMaterial({
- *     color: 0x00ff00
- * })
- * const plane = new THREE.Mesh(planeGeometry, planeMaterial);
- * plane.receiveShadow = true;
- * scene.add(plane);
- * //Create a helper for the shadow camera (optional)
- * const helper = new THREE.CameraHelper(light.shadow.camera);
- * scene.add(helper);
- * ```
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/shadows/DirectionalLightShadow | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/DirectionalLightShadow.js | Source}
+ * Represents the shadow configuration of directional lights.
  */
 export class DirectionalLightShadow extends LightShadow<OrthographicCamera> {
     /**
-     * Create a new instance of {@link DirectionalLightShadow}
+     * Constructs a new directional light shadow.
      */
     constructor();
-
-    /**
-     * Read-only flag to check if a given object is of type {@link DirectionalLightShadow}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isDirectionalLightShadow: true;
-
     /**
-     * The light's view of the world.
-     * @remarks This is used to generate a depth map of the scene; objects behind other objects from the light's perspective will be in shadow.
-     * @defaultValue is an {@link THREE.OrthographicCamera | OrthographicCamera} with
-     * {@link OrthographicCamera.left | left} and {@link OrthographicCamera.bottom | bottom} set to -5,
-     * {@link OrthographicCamera.right | right} and {@link OrthographicCamera.top | top} set to 5,
-     * the {@link OrthographicCamera.near | near} clipping plane at 0.5 and
-     * the {@link OrthographicCamera.far | far} clipping plane at 500.
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    camera: OrthographicCamera;
+    readonly isDirectionalLightShadow: boolean;
 }

three/src/lights/HemisphereLight.d.ts

@@ -1,61 +1,41 @@
+import { JSONMeta } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
-import { Vector3 } from "../math/Vector3.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+
+export interface HemisphereLightJSON extends LightJSON {
+    groundColor: number;
+}
 
 /**
- * A light source positioned directly above the scene, with color fading from the sky color to the ground color.
- * @remarks This light cannot be used to cast shadows.
- * @example
- * ```typescript
- * const light = new THREE.HemisphereLight(0xffffbb, 0x080820, 1);
- * scene.add(light);
+ * A light source positioned directly above the scene, with color fading from
+ * the sky color to the ground color.
+ *
+ * This light cannot be used to cast shadows.
+ *
+ * ```js
+ * const light = new THREE.HemisphereLight( 0xffffbb, 0x080820, 1 );
+ * scene.add( light );
  * ```
- * @see Example: {@link https://threejs.org/examples/#webgl_animation_skinning_blending | animation / skinning / blending }
- * @see Example: {@link https://threejs.org/examples/#webgl_lights_hemisphere | lights / hemisphere }
- * @see Example: {@link https://threejs.org/examples/#misc_controls_pointerlock | controls / pointerlock }
- * @see Example: {@link https://threejs.org/examples/#webgl_loader_collada_kinematics | loader / collada / kinematics }
- * @see Example: {@link https://threejs.org/examples/#webgl_loader_stl | loader / stl }
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/HemisphereLight | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/HemisphereLight.js | Source}
  */
-export class HemisphereLight extends Light<undefined> {
+export class HemisphereLight extends Light {
     /**
-     * Creates a new {@link HemisphereLight}.
-     * @param skyColor Hexadecimal color of the sky. Expects a `Integer`. Default `0xffffff` _(white)_.
-     * @param groundColor Hexadecimal color of the ground. Expects a `Integer`. Default `0xffffff` _(white)_.
-     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`.
+     * Constructs a new hemisphere light.
+     *
+     * @param {(number|Color|string)} [skyColor=0xffffff] - The light's sky color.
+     * @param {(number|Color|string)} [groundColor=0xffffff] - The light's ground color.
+     * @param {number} [intensity=1] - The light's strength/intensity.
      */
     constructor(skyColor?: ColorRepresentation, groundColor?: ColorRepresentation, intensity?: number);
-
     /**
-     * Read-only flag to check if a given object is of type {@link HemisphereLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    readonly isHemisphereLight: true;
-
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `HemisphereLight`
-     */
-    override readonly type: string | "HemisphereLight";
-
-    /**
-     * This is set equal to {@link THREE.Object3D.DEFAULT_UP}, so that the light shines from the top down.
-     * @defaultValue {@link Object3D.DEFAULT_UP} _(0, 1, 0)_
-     */
-    override readonly position: Vector3;
-
-    /**
-     * The light's sky color, as passed in the constructor.
-     * @defaultValue `new THREE.Color()` set to white _(0xffffff)_.
-     */
-    override color: Color;
-
+    readonly isHemisphereLight: boolean;
     /**
-     * The light's ground color, as passed in the constructor.
-     * @defaultValue `new THREE.Color()` set to white _(0xffffff)_.
+     * The light's ground color.
      */
     groundColor: Color;
+    copy(source: HemisphereLight, recursive?: boolean): this;
+    toJSON(meta?: JSONMeta): HemisphereLightJSON;
 }