@types/three 0.166.0 → 0.167.1

three/src/animation/AnimationClip.d.ts

@@ -1,7 +1,15 @@
 import { AnimationBlendMode } from "../constants.js";
 import { Vector3 } from "../math/Vector3.js";
 import { Bone } from "../objects/Bone.js";
-import { KeyframeTrack } from "./KeyframeTrack.js";
+import { KeyframeTrack, KeyframeTrackJSON } from "./KeyframeTrack.js";
+
+export interface AnimationClipJSON {
+    name: string;
+    duration: number;
+    tracks: KeyframeTrackJSON[];
+    uuid: string;
+    blendMode: AnimationBlendMode;
+}
 
 export interface MorphTarget {
     name: string;
@@ -45,7 +53,7 @@ export class AnimationClip {
         fps: number,
         noLoop: boolean,
     ): AnimationClip[];
-    static parse(json: any): AnimationClip;
-    static parseAnimation(animation: any, bones: Bone[]): AnimationClip;
-    static toJSON(clip: AnimationClip): any;
+    static parse(json: AnimationClipJSON): AnimationClip;
+    static parseAnimation(animation: AnimationClipJSON, bones: Bone[]): AnimationClip;
+    static toJSON(clip: AnimationClip): AnimationClipJSON;
 }

three/src/animation/AnimationUtils.d.ts

@@ -1,10 +1,14 @@
 import { AnimationClip } from "./AnimationClip.js";
 
-export function convertArray(array: any, type: any, forceClone: boolean): any;
-export function isTypedArray(object: any): boolean;
-export function getKeyframeOrder(times: number[]): number[];
-export function sortedArray(values: any[], stride: number, order: number[]): any[];
-export function flattenJSON(jsonKeys: string[], times: any[], values: any[], valuePropertyName: string): void;
+declare function convertArray(array: any, type: any, forceClone: boolean): any;
+
+declare function isTypedArray(object: any): boolean;
+
+declare function getKeyframeOrder(times: number[]): number[];
+
+declare function sortedArray(values: any[], stride: number, order: number[]): any[];
+
+declare function flattenJSON(jsonKeys: string[], times: any[], values: any[], valuePropertyName: string): void;
 
 /**
  * @param sourceClip
@@ -13,7 +17,7 @@ export function flattenJSON(jsonKeys: string[], times: any[], values: any[], val
  * @param endFrame
  * @param [fps=30]
  */
-export function subclip(
+declare function subclip(
     sourceClip: AnimationClip,
     name: string,
     startFrame: number,
@@ -27,9 +31,30 @@ export function subclip(
  * @param [referenceClip=targetClip]
  * @param [fps=30]
  */
-export function makeClipAdditive(
+declare function makeClipAdditive(
     targetClip: AnimationClip,
     referenceFrame?: number,
     referenceClip?: AnimationClip,
     fps?: number,
 ): AnimationClip;
+
+declare const AnimationUtils: {
+    convertArray: typeof convertArray;
+    isTypedArray: typeof isTypedArray;
+    getKeyframeOrder: typeof getKeyframeOrder;
+    sortedArray: typeof sortedArray;
+    flattenJSON: typeof flattenJSON;
+    subclip: typeof subclip;
+    makeClipAdditive: typeof makeClipAdditive;
+};
+
+export {
+    AnimationUtils,
+    convertArray,
+    flattenJSON,
+    getKeyframeOrder,
+    isTypedArray,
+    makeClipAdditive,
+    sortedArray,
+    subclip,
+};

three/src/animation/KeyframeTrack.d.ts

@@ -4,6 +4,14 @@ import { CubicInterpolant } from "../math/interpolants/CubicInterpolant.js";
 import { DiscreteInterpolant } from "../math/interpolants/DiscreteInterpolant.js";
 import { LinearInterpolant } from "../math/interpolants/LinearInterpolant.js";
 
+export interface KeyframeTrackJSON {
+    name: string;
+    times: number[];
+    values: number[];
+    interpolation?: InterpolationModes;
+    type: string;
+}
+
 export class KeyframeTrack {
     /**
      * @param name
@@ -43,5 +51,5 @@ export class KeyframeTrack {
     optimize(): KeyframeTrack;
     clone(): this;
 
-    static toJSON(track: KeyframeTrack): any;
+    static toJSON(track: KeyframeTrack): KeyframeTrackJSON;
 }

three/src/animation/PropertyBinding.d.ts

@@ -6,7 +6,16 @@ export interface ParseTrackNameResults {
     propertyIndex: string;
 }
 
-export class PropertyBinding {
+declare class Composite {
+    constructor(targetGroup: any, path: any, parsedPath?: any);
+
+    getValue(array: any, offset: number): any;
+    setValue(array: any, offset: number): void;
+    bind(): void;
+    unbind(): void;
+}
+
+declare class PropertyBinding {
     constructor(rootNode: any, path: string, parsedPath?: any);
 
     path: string;
@@ -25,19 +34,10 @@ export class PropertyBinding {
     GetterByBindingType: Array<() => void>;
     SetterByBindingTypeAndVersioning: Array<Array<() => void>>;
 
-    static create(root: any, path: any, parsedPath?: any): PropertyBinding | PropertyBinding.Composite;
+    static create(root: any, path: any, parsedPath?: any): PropertyBinding | Composite;
     static sanitizeNodeName(name: string): string;
     static parseTrackName(trackName: string): ParseTrackNameResults;
     static findNode(root: any, nodeName: string): any;
 }
 
-export namespace PropertyBinding {
-    class Composite {
-        constructor(targetGroup: any, path: any, parsedPath?: any);
-
-        getValue(array: any, offset: number): any;
-        setValue(array: any, offset: number): void;
-        bind(): void;
-        unbind(): void;
-    }
-}
+export { PropertyBinding };

three/src/cameras/OrthographicCamera.d.ts

@@ -1,5 +1,30 @@
+import { JSONMeta, Object3DJSON, Object3DJSONObject } from "../core/Object3D.js";
 import { Camera } from "./Camera.js";
 
+export interface OrthographicCameraJSONObject extends Object3DJSONObject {
+    zoom: number;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    near: number;
+    far: number;
+
+    view?: {
+        enabled: boolean;
+        fullWidth: number;
+        fullHeight: number;
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+}
+
+export interface OrthographicCameraJSON extends Object3DJSON {
+    object: OrthographicCameraJSONObject;
+}
+
 /**
  * Camera that uses {@link https://en.wikipedia.org/wiki/Orthographic_projection | orthographic projection}.
  * In this projection mode, an object's size in the rendered image stays constant regardless of its distance from the camera.
@@ -144,4 +169,6 @@ export class OrthographicCamera extends Camera {
      * Removes any offset set by the {@link setViewOffset | .setViewOffset} method.
      */
     clearViewOffset(): void;
+
+    toJSON(meta?: JSONMeta): OrthographicCameraJSON;
 }

three/src/cameras/PerspectiveCamera.d.ts

@@ -1,6 +1,35 @@
+import { JSONMeta, Object3DJSON, Object3DJSONObject } from "../core/Object3D.js";
 import { Vector2 } from "../math/Vector2.js";
 import { Camera } from "./Camera.js";
 
+export interface PerspectiveCameraJSONObject extends Object3DJSONObject {
+    fov: number;
+    zoom: number;
+
+    near: number;
+    far: number;
+    focus: number;
+
+    aspect: number;
+
+    view?: {
+        enabled: boolean;
+        fullWidth: number;
+        fullHeight: number;
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+
+    filmGauge: number;
+    filmOffset: number;
+}
+
+export interface PerspectiveCameraJSON extends Object3DJSON {
+    object: PerspectiveCameraJSONObject;
+}
+
 /**
  * Camera that uses {@link https://en.wikipedia.org/wiki/Perspective_(graphical) | perspective projection}.
  * This projection mode is designed to mimic the way the human eye sees
@@ -220,4 +249,6 @@ export class PerspectiveCamera extends Camera {
      * @deprecated Use {@link PerspectiveCamera.setFocalLength | .setFocalLength()} and {@link PerspectiveCamera.filmGauge | .filmGauge} instead.
      */
     setLens(focalLength: number, frameHeight?: number): void;
+
+    toJSON(meta?: JSONMeta): PerspectiveCameraJSON;
 }

three/src/constants.d.ts

@@ -679,7 +679,13 @@ export type TrianglesDrawModes = typeof TrianglesDrawMode | typeof TriangleStrip
 
 export const BasicDepthPacking: 3200;
 export const RGBADepthPacking: 3201;
-export type DepthPackingStrategies = typeof BasicDepthPacking | typeof RGBADepthPacking;
+export const RGBDepthPacking: 3202;
+export const RGDepthPacking: 3203;
+export type DepthPackingStrategies =
+    | typeof BasicDepthPacking
+    | typeof RGBADepthPacking
+    | typeof RGBDepthPacking
+    | typeof RGDepthPacking;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Normal Map types

three/src/core/BufferAttribute.d.ts

@@ -13,6 +13,16 @@ export type TypedArray =
     | Float32Array
     | Float64Array;
 
+export interface BufferAttributeJSON {
+    itemSize: number;
+    type: string;
+    array: number[];
+    normalized: boolean;
+
+    name?: string;
+    usage?: Usage;
+}
+
 /**
  * This class stores data for an attribute (such as vertex positions, face indices, normals, colors, UVs, and any custom attributes )
  * associated with a {@link THREE.BufferGeometry | BufferGeometry}, which allows for more efficient passing of data to the GPU
@@ -336,12 +346,7 @@ export class BufferAttribute {
     /**
      * Convert this object to three.js to the `data.attributes` part of {@link https://github.com/mrdoob/three.js/wiki/JSON-Geometry-format-4 | JSON Geometry format v4},
      */
-    toJSON(): {
-        itemSize: number;
-        type: string;
-        array: number[];
-        normalized: boolean;
-    };
+    toJSON(): BufferAttributeJSON;
 }
 
 /**

three/src/core/BufferGeometry.d.ts

@@ -3,8 +3,8 @@ import { Matrix4 } from "../math/Matrix4.js";
 import { Quaternion } from "../math/Quaternion.js";
 import { Sphere } from "../math/Sphere.js";
 import { Vector2 } from "../math/Vector2.js";
-import { Vector3 } from "../math/Vector3.js";
-import { BufferAttribute } from "./BufferAttribute.js";
+import { Vector3, Vector3Tuple } from "../math/Vector3.js";
+import { BufferAttribute, BufferAttributeJSON } from "./BufferAttribute.js";
 import { EventDispatcher } from "./EventDispatcher.js";
 import { GLBufferAttribute } from "./GLBufferAttribute.js";
 import { InterleavedBufferAttribute } from "./InterleavedBufferAttribute.js";
@@ -15,6 +15,29 @@ export type NormalOrGLBufferAttributes = Record<
     BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute
 >;
 
+export interface BufferGeometryJSON {
+    metadata?: { version: number; type: string; generator: string };
+
+    uuid: string;
+    type: string;
+
+    name?: string;
+    userData?: Record<string, unknown>;
+
+    data?: {
+        attributes: Record<string, BufferAttributeJSON>;
+
+        index?: { type: string; array: number[] };
+
+        morphAttributes?: Record<string, BufferAttributeJSON[]>;
+        morphTargetsRelative?: boolean;
+
+        groups?: GeometryGroup[];
+
+        boundingSphere?: { center: Vector3Tuple; radius: number };
+    };
+}
+
 export interface GeometryGroup {
     /**
      * Specifies the first element in this draw call – the first vertex for non-indexed geometry, otherwise the first triangle index.
@@ -378,7 +401,7 @@ export class BufferGeometry<
     /**
      * Convert the buffer geometry to three.js {@link https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 | JSON Object/Scene format}.
      */
-    toJSON(): {};
+    toJSON(): BufferGeometryJSON;
 
     /**
      * Creates a clone of this BufferGeometry

three/src/core/InterleavedBufferAttribute.d.ts

@@ -1,4 +1,4 @@
-import { Matrix } from "../math/Matrix3.js";
+import { Matrix3 } from "../math/Matrix3.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { BufferAttribute, TypedArray } from "./BufferAttribute.js";
 import { InterleavedBuffer } from "./InterleavedBuffer.js";
@@ -84,13 +84,13 @@ export class InterleavedBufferAttribute {
      * Applies normal matrix {@link Matrix3 | m} to every Vector3 element of this InterleavedBufferAttribute.
      * @param m
      */
-    applyNormalMatrix(m: Matrix): this;
+    applyNormalMatrix(m: Matrix3): this;
 
     /**
      * Applies matrix {@link Matrix4 | m} to every Vector3 element of this InterleavedBufferAttribute, interpreting the elements as a direction vectors.
      * @param m
      */
-    transformDirection(m: Matrix): this;
+    transformDirection(m: Matrix4): this;
 
     /**
      * Returns the given component of the vector at the given index.

three/src/core/Object3D.d.ts

@@ -1,19 +1,64 @@
-import { AnimationClip } from "../animation/AnimationClip.js";
+import { AnimationClip, AnimationClipJSON } from "../animation/AnimationClip.js";
 import { Camera } from "../cameras/Camera.js";
-import { Material } from "../materials/Material.js";
+import { ShapeJSON } from "../extras/core/Shape.js";
+import { Material, MaterialJSON } from "../materials/Material.js";
 import { Euler } from "../math/Euler.js";
 import { Matrix3 } from "../math/Matrix3.js";
-import { Matrix4 } from "../math/Matrix4.js";
+import { Matrix4, Matrix4Tuple } from "../math/Matrix4.js";
 import { Quaternion } from "../math/Quaternion.js";
-import { Vector3 } from "../math/Vector3.js";
+import { Vector3, Vector3Tuple } from "../math/Vector3.js";
 import { Group } from "../objects/Group.js";
+import { SkeletonJSON } from "../objects/Skeleton.js";
 import { WebGLRenderer } from "../renderers/WebGLRenderer.js";
 import { Scene } from "../scenes/Scene.js";
-import { BufferGeometry } from "./BufferGeometry.js";
+import { SourceJSON } from "../textures/Source.js";
+import { TextureJSON } from "../textures/Texture.js";
+import { BufferGeometry, BufferGeometryJSON } from "./BufferGeometry.js";
 import { EventDispatcher } from "./EventDispatcher.js";
 import { Layers } from "./Layers.js";
 import { Intersection, Raycaster } from "./Raycaster.js";
 
+export interface Object3DJSONObject {
+    uuid: string;
+    type: string;
+
+    name?: string;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+    visible?: boolean;
+    frustumCulled?: boolean;
+    renderOrder?: number;
+    userData?: Record<string, unknown>;
+
+    layers: number;
+    matrix: Matrix4Tuple;
+    up: Vector3Tuple;
+
+    matrixAutoUpdate?: boolean;
+
+    material?: string | string[];
+
+    children?: string[];
+
+    animations?: string[];
+}
+
+export interface Object3DJSON {
+    metadata?: { version: number; type: string; generator: string };
+    object: Object3DJSONObject;
+}
+
+export interface JSONMeta {
+    geometries: Record<string, BufferGeometryJSON>;
+    materials: Record<string, MaterialJSON>;
+    textures: Record<string, TextureJSON>;
+    images: Record<string, SourceJSON>;
+    shapes: Record<string, ShapeJSON>;
+    skeletons: Record<string, SkeletonJSON>;
+    animations: Record<string, AnimationClipJSON>;
+    nodes: Record<string, unknown>;
+}
+
 export interface Object3DEventMap {
     /**
      * Fires when the object has been added to its parent object.
@@ -608,7 +653,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
      * Convert the object to three.js {@link https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 | JSON Object/Scene format}.
      * @param meta Object containing metadata such as materials, textures or images for the object.
      */
-    toJSON(meta?: { geometries: any; materials: any; textures: any; images: any }): any;
+    toJSON(meta?: JSONMeta): Object3DJSON;
 
     /**
      * Returns a clone of `this` object and optionally all descendants.

three/src/extras/DataUtils.d.ts

@@ -4,7 +4,7 @@
  * @see {@link https://threejs.org/docs/index.html#api/en/extras/DataUtils | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/DataUtils.js | Source}
  */
-export function toHalfFloat(val: number): number;
+declare function toHalfFloat(val: number): number;
 
 /**
  * Returns a single precision floating point value from the given half precision floating point value.
@@ -12,4 +12,11 @@ export function toHalfFloat(val: number): number;
  * @see {@link https://threejs.org/docs/index.html#api/en/extras/DataUtils | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/DataUtils.js | Source}
  */
-export function fromHalfFloat(val: number): number;
+declare function fromHalfFloat(val: number): number;
+
+declare const DataUtils: {
+    toHalfFloat: typeof toHalfFloat;
+    fromHalfFloat: typeof fromHalfFloat;
+};
+
+export { DataUtils, fromHalfFloat, toHalfFloat };

three/src/extras/ImageUtils.d.ts

@@ -1,17 +1,14 @@
-import { Mapping } from "../constants.js";
-import { Texture } from "../textures/Texture.js";
-
 /**
  * A class containing utility functions for images.
  * @see {@link https://threejs.org/docs/index.html#api/en/extras/ImageUtils | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/ImageUtils.js | Source}
  */
-export namespace ImageUtils {
+declare class ImageUtils {
     /**
      * Returns a data URI containing a representation of the given image.
      * @param image The image object.
      */
-    function getDataURL(
+    static getDataURL(
         image: HTMLImageElement | HTMLCanvasElement | CanvasImageSource | ImageBitmap | ImageData,
     ): string;
 
@@ -19,15 +16,17 @@ export namespace ImageUtils {
      * Converts the given sRGB image data to linear color space.
      * @param image
      */
-    function sRGBToLinear(image: HTMLImageElement | HTMLCanvasElement | ImageBitmap): HTMLCanvasElement;
+    static sRGBToLinear(image: HTMLImageElement | HTMLCanvasElement | ImageBitmap): HTMLCanvasElement;
 
     /**
      * Converts the given sRGB image data to linear color space.
      * @param image
      */
-    function sRGBToLinear(image: ImageData): {
+    static sRGBToLinear(image: ImageData): {
         data: ImageData["data"];
         width: ImageData["width"];
         height: ImageData["height"];
     };
 }
+
+export { ImageUtils };

three/src/extras/core/Curve.d.ts

@@ -1,6 +1,12 @@
 import { Vector2 } from "../../math/Vector2.js";
 import { Vector3 } from "../../math/Vector3.js";
 
+export interface CurveJSON {
+    metadata: { version: number; type: string; generator: string };
+    arcLengthDivisions: number;
+    type: string;
+}
+
 /**
  * An abstract base class for creating a {@link Curve} object that contains methods for interpolation
  * @remarks
@@ -146,11 +152,11 @@ export abstract class Curve<TVector extends Vector2 | Vector3> {
     /**
      * Returns a JSON object representation of this instance.
      */
-    toJSON(): {};
+    toJSON(): CurveJSON;
 
     /**
      * Copies the data from the given JSON object to this instance.
      * @param json
      */
-    fromJSON(json: {}): this;
+    fromJSON(json: CurveJSON): this;
 }

three/src/extras/core/CurvePath.d.ts

@@ -1,6 +1,11 @@
 import { Vector2 } from "../../math/Vector2.js";
 import { Vector3 } from "../../math/Vector3.js";
-import { Curve } from "./Curve.js";
+import { Curve, CurveJSON } from "./Curve.js";
+
+export interface CurvePathJSON extends CurveJSON {
+    autoClose: boolean;
+    curves: CurveJSON[];
+}
 
 /**
  * Curved Path - a curve path is simply a array of connected curves, but retains the api of a curve.
@@ -66,4 +71,7 @@ export class CurvePath<TVector extends Vector2 | Vector3> extends Curve<TVector>
      * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `40`
      */
     override getSpacedPoints(divisions?: number): TVector[];
+
+    toJSON(): CurvePathJSON;
+    fromJSON(json: CurvePathJSON): this;
 }

three/src/extras/core/Path.d.ts

@@ -1,5 +1,9 @@
-import { Vector2 } from "../../math/Vector2.js";
-import { CurvePath } from "./CurvePath.js";
+import { Vector2, Vector2Tuple } from "../../math/Vector2.js";
+import { CurvePath, CurvePathJSON } from "./CurvePath.js";
+
+export interface PathJSON extends CurvePathJSON {
+    currentPoint: Vector2Tuple;
+}
 
 /**
  * A 2D {@link Path} representation.
@@ -156,4 +160,7 @@ export class Path extends CurvePath<Vector2> {
      * @param points An array of {@link Vector2 | Vector2's}
      */
     splineThru(pts: Vector2[]): this;
+
+    toJSON(): PathJSON;
+    fromJSON(json: PathJSON): this;
 }

three/src/extras/core/Shape.d.ts

@@ -1,5 +1,10 @@
 import { Vector2 } from "../../math/Vector2.js";
-import { Path } from "./Path.js";
+import { Path, PathJSON } from "./Path.js";
+
+export interface ShapeJSON extends PathJSON {
+    uuid: string;
+    holes: PathJSON[];
+}
 
 /**
  * Defines an arbitrary 2d {@link Shape} plane using paths with optional holes
@@ -75,4 +80,7 @@ export class Shape extends Path {
      * @param divisions The fineness of the result. Expects a `Integer`
      */
     getPointsHoles(divisions: number): Vector2[][];
+
+    toJSON(): ShapeJSON;
+    fromJSON(json: ShapeJSON): this;
 }

three/src/lights/Light.d.ts

@@ -1,6 +1,21 @@
-import { Object3D } from "../core/Object3D.js";
+import { JSONMeta, Object3D, Object3DJSON } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
-import { LightShadow } from "./LightShadow.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.
@@ -62,4 +77,6 @@ export abstract class Light<TShadowSupport extends LightShadow | undefined = Lig
      * Call this method whenever this instance is no longer used in your app.
      */
     dispose(): void;
+
+    toJSON(meta?: JSONMeta): LightJSON;
 }

three/src/lights/LightShadow.d.ts

@@ -1,11 +1,22 @@
 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 } from "../math/Vector2.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}
@@ -127,7 +138,7 @@ export class LightShadow<TCamera extends Camera = Camera> {
     /**
      * Serialize this LightShadow.
      */
-    toJSON(): {};
+    toJSON(): LightShadowJSON;
 
     /**
      * Gets the shadow cameras frustum

three/src/lights/webgpu/IESSpotLight.d.ts

@@ -0,0 +1,6 @@
+import { Texture } from "../../textures/Texture.js";
+import { SpotLight } from "../SpotLight.js";
+
+export default class IESSpotLight extends SpotLight {
+    iesMap: Texture | null;
+}