@needle-tools/three 0.169.12 → 0.169.13

package/types/src/helpers/SpotLightHelper.d.ts

@@ -0,0 +1,77 @@
+import { Object3D } from "../core/Object3D.js";
+import { Light } from "../lights/Light.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);
+ * ```
+ * @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`
+     */
+    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;
+
+    /**
+     * Reference to the spotLight's {@link Object3D.matrixWorld | matrixWorld}.
+     */
+    matrix: Matrix4;
+
+    /**
+     * 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`
+     */
+    color: ColorRepresentation | undefined;
+
+    /**
+     * 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`.
+     */
+    override matrixAutoUpdate: boolean;
+
+    /**
+     * Updates the light helper.
+     */
+    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;
+}

package/types/src/lights/AmbientLight.d.ts

@@ -0,0 +1,36 @@
+import { ColorRepresentation } from "../math/Color.js";
+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);
+ * ```
+ * @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> {
+    /**
+     * 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`
+     */
+    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`
+     */
+    override readonly type: string | "AmbientLight";
+}

package/types/src/lights/DirectionalLight.d.ts

@@ -0,0 +1,103 @@
+import { 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";
+
+/**
+ * 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
+ * @remarks
+ * 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
+ * // White directional light at half intensity shining from the top.
+ * const {@link 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> {
+    /**
+     * 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`
+     */
+    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)_
+     */
+    override readonly position: Vector3;
+
+    /**
+     * 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.
+     *
+     * 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)_
+     */
+    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.
+     */
+    dispose(): void;
+}

package/types/src/lights/DirectionalLightShadow.d.ts

@@ -0,0 +1,73 @@
+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}
+ */
+export class DirectionalLightShadow extends LightShadow<OrthographicCamera> {
+    /**
+     * Create a new instance of {@link DirectionalLightShadow}
+     */
+    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.
+     */
+    camera: OrthographicCamera;
+}

package/types/src/lights/HemisphereLight.d.ts

@@ -0,0 +1,61 @@
+import { Color, ColorRepresentation } from "../math/Color.js";
+import { Vector3 } from "../math/Vector3.js";
+import { Light } from "./Light.js";
+
+/**
+ * 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);
+ * ```
+ * @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> {
+    /**
+     * 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`.
+     */
+    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`
+     */
+    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;
+
+    /**
+     * The light's ground color, as passed in the constructor.
+     * @defaultValue `new THREE.Color()` set to white _(0xffffff)_.
+     */
+    groundColor: Color;
+}

package/types/src/lights/Light.d.ts

@@ -0,0 +1,82 @@
+import { JSONMeta, Object3D, Object3DJSON } from "../core/Object3D.js";
+import { Color, ColorRepresentation } from "../math/Color.js";
+import { LightShadow, LightShadowJSON } from "./LightShadow.js";
+
+export interface LightJSON extends Object3DJSON {
+    color: number;
+    intensity: number;
+
+    groundColor?: number;
+
+    distance?: number;
+    angle?: number;
+    decay?: number;
+    penumbra?: number;
+
+    shadow?: LightShadowJSON;
+    target?: string;
+}
+
+/**
+ * Abstract base class for lights.
+ * @remarks All other light types inherit the properties and methods described here.
+ */
+export abstract class Light<TShadowSupport extends LightShadow | undefined = LightShadow | undefined> extends Object3D {
+    /**
+     * Creates a new {@link Light}
+     * @remarks
+     * **Note** that this is not intended to be called directly (use one of derived classes instead).
+     * @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`.
+     */
+    constructor(color?: 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`
+     */
+    readonly isLight: true;
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `Light`
+     */
+    override readonly type: string | "Light";
+
+    /**
+     * Color of the light. \
+     * @defaultValue `new THREE.Color(0xffffff)` _(white)_.
+     */
+    color: Color;
+
+    /**
+     * The light's intensity, or strength.
+     * The units of intensity depend on the type of light.
+     * @defaultValue `1`
+     */
+    intensity: number;
+
+    /**
+     * A {@link THREE.LightShadow | LightShadow} used to calculate shadows for this light.
+     * @remarks Available only on Light's that support shadows.
+     */
+    shadow: TShadowSupport;
+
+    /**
+     * Copies value of all the properties from the {@link Light | source} to this instance.
+     * @param source
+     * @param recursive
+     */
+    copy(source: this, recursive?: boolean): this;
+
+    /**
+     * 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;
+
+    toJSON(meta?: JSONMeta): LightJSON;
+}

package/types/src/lights/LightProbe.d.ts

@@ -0,0 +1,47 @@
+import { SphericalHarmonics3 } from "../math/SphericalHarmonics3.js";
+import { Light } from "./Light.js";
+
+/**
+ * Light probes are an alternative way of adding light to a 3D scene.
+ * @remarks
+ * Unlike classical light sources (e.g
+ * directional, point or spot lights), light probes do not emit light
+ * Instead they store information about light passing through 3D space
+ * During rendering, the light that hits a 3D object is approximated by using the data from the light probe.
+ * Light probes are usually created from (radiance) environment maps
+ * The class {@link THREE.LightProbeGenerator | LightProbeGenerator} can be used to create light probes from
+ * instances of {@link THREE.CubeTexture | CubeTexture} or {@link THREE.WebGLCubeRenderTarget | WebGLCubeRenderTarget}
+ * However, light estimation data could also be provided in other forms e.g
+ * by WebXR
+ * This enables the rendering of augmented reality content that reacts to real world lighting.
+ * The current probe implementation in three.js supports so-called diffuse light probes
+ * This type of light probe is functionally equivalent to an irradiance environment map.
+ * @see Example: {@link https://threejs.org/examples/#webgl_lightprobe | WebGL / light probe }
+ * @see Example: {@link https://threejs.org/examples/#webgl_lightprobe_cubecamera | WebGL / light probe / cube camera }
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/LightProbe | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/LightProbe.js | Source}
+ */
+export class LightProbe extends Light {
+    /**
+     * Creates a new LightProbe.
+     * @param sh An instance of {@link THREE.SphericalHarmonics3 | SphericalHarmonics3}. Default `new THREE.SphericalHarmonics3()``.
+     * @param intensity Numeric value of the light probe's intensity. Expects a `Float`. Default `1`.
+     */
+    constructor(sh?: SphericalHarmonics3, 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 isLightProbe: true;
+
+    /**
+     * A light probe uses spherical harmonics to encode lighting information.
+     * @defaultValue `new THREE.SphericalHarmonics3()`
+     */
+    sh: SphericalHarmonics3;
+
+    /** @internal */
+    fromJSON(json: {}): LightProbe;
+}

package/types/src/lights/LightShadow.d.ts

@@ -0,0 +1,169 @@
+import { Camera } from "../cameras/Camera.js";
+import { Object3DJSONObject } from "../core/Object3D.js";
+import { Frustum } from "../math/Frustum.js";
+import { Matrix4 } from "../math/Matrix4.js";
+import { Vector2, Vector2Tuple } from "../math/Vector2.js";
+import { Vector4 } from "../math/Vector4.js";
+import { WebGLRenderTarget } from "../renderers/WebGLRenderTarget.js";
+import { Light } from "./Light.js";
+
+export interface LightShadowJSON {
+    intensity?: number;
+    bias?: number;
+    normalBias?: number;
+    radius?: number;
+    mapSize?: Vector2Tuple;
+
+    camera: Omit<Object3DJSONObject, "matrix">;
+}
+
+/**
+ * Serves as a base class for the other shadow classes.
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/shadows/LightShadow | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/LightShadow.js | Source}
+ */
+export class LightShadow<TCamera extends Camera = Camera> {
+    /**
+     * Create a new instance of {@link LightShadow}
+     * @param camera The light's view of the world.
+     */
+    constructor(camera: TCamera);
+
+    /**
+     * The light's view of the world.
+     * @remark This is used to generate a depth map of the scene; objects behind other objects from the light's perspective will be in shadow.
+     */
+    camera: TCamera;
+
+    /**
+     * The intensity of the shadow. The default is `1`. Valid values are in the range `[0, 1]`.
+     */
+    intensity: number;
+
+    /**
+     * Shadow map bias, how much to add or subtract from the normalized depth when deciding whether a surface is in shadow.
+     * @remark The Very tiny adjustments here (in the order of 0.0001) may help reduce artifacts in shadows.
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
+     */
+    bias: number;
+
+    /**
+     * Defines how much the position used to query the shadow map is offset along the object normal.
+     * @remark The Increasing this value can be used to reduce shadow acne especially in large scenes where light shines onto geometry at a shallow angle.
+     * @remark The cost is that shadows may appear distorted.
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
+     */
+    normalBias: number;
+
+    /**
+     * Setting this to values greater than 1 will blur the edges of the shadow.toi
+     * @remark High values will cause unwanted banding effects in the shadows - a greater {@link LightShadow.mapSize | mapSize
+     *  will allow for a higher value to be used here before these effects become visible.
+     * @remark If {@link THREE.WebGLRenderer.shadowMap.type | WebGLRenderer.shadowMap.type} is set to {@link Renderer | PCFSoftShadowMap},
+     * radius has no effect and it is recommended to increase softness by decreasing {@link LightShadow.mapSize | mapSize} instead.
+     * @remark Note that this has no effect if the {@link THREE.WebGLRenderer.shadowMap | WebGLRenderer.shadowMap}.{@link THREE.WebGLShadowMap.type | type}
+     * is set to {@link THREE.BasicShadowMap | BasicShadowMap}.
+     * @remarks Expects a `Float`
+     * @defaultValue `1`
+     */
+    radius: number;
+
+    /**
+     * The amount of samples to use when blurring a VSM shadow map.
+     * @remarks Expects a `Integer`
+     * @defaultValue `8`
+     */
+    blurSamples: number;
+
+    /**
+     * A {@link THREE.Vector2 | Vector2} defining the width and height of the shadow map.
+     * @remarks Higher values give better quality shadows at the cost of computation time.
+     * @remarks Values must be powers of 2, up to the {@link THREE.WebGLRenderer.capabilities | WebGLRenderer.capabilities}.maxTextureSize for a given device,
+     * although the width and height don't have to be the same (so, for example, (512, 1024) is valid).
+     * @defaultValue `new THREE.Vector2(512, 512)`
+     */
+    mapSize: Vector2;
+
+    /**
+     * The depth map generated using the internal camera; a location beyond a pixel's depth is in shadow. Computed internally during rendering.
+     * @defaultValue null
+     */
+    map: WebGLRenderTarget | null;
+
+    /**
+     * The distribution map generated using the internal camera; an occlusion is calculated based on the distribution of depths. Computed internally during rendering.
+     * @defaultValue null
+     */
+    mapPass: WebGLRenderTarget | null;
+
+    /**
+     * Model to shadow camera space, to compute location and depth in shadow map.
+     * Stored in a {@link Matrix4 | Matrix4}.
+     * @remarks This is computed internally during rendering.
+     * @defaultValue new THREE.Matrix4()
+     */
+    matrix: Matrix4;
+
+    /**
+     * Enables automatic updates of the light's shadow. If you do not require dynamic lighting / shadows, you may set this to `false`.
+     * @defaultValue `true`
+     */
+    autoUpdate: boolean;
+
+    /**
+     * When set to `true`, shadow maps will be updated in the next `render` call.
+     * If you have set {@link autoUpdate} to `false`, you will need to set this property to `true` and then make a render call to update the light's shadow.
+     * @defaultValue `false`
+     */
+    needsUpdate: boolean;
+
+    /**
+     * Used internally by the renderer to get the number of viewports that need to be rendered for this shadow.
+     */
+    getViewportCount(): number;
+
+    /**
+     * Copies value of all the properties from the {@link {@link LightShadow} | source} to this Light.
+     * @param source
+     */
+    copy(source: LightShadow): this;
+
+    /**
+     * Creates a new {@link LightShadow} with the same properties as this one.
+     */
+    clone(recursive?: boolean): this;
+
+    /**
+     * Serialize this LightShadow.
+     */
+    toJSON(): LightShadowJSON;
+
+    /**
+     * Gets the shadow cameras frustum
+     * @remarks
+     * Used internally by the renderer to cull objects.
+     */
+    getFrustum(): Frustum;
+
+    /**
+     * Update the matrices for the camera and shadow, used internally by the renderer.
+     * @param light The light for which the shadow is being rendered.
+     */
+    updateMatrices(light: Light): void;
+
+    getViewport(viewportIndex: number): Vector4;
+
+    /**
+     * Used internally by the renderer to extend the shadow map to contain all viewports
+     */
+    getFrameExtents(): Vector2;
+
+    /**
+     * 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;
+}