three-stdlib 2.35.6 → 2.35.8

package/libs/MeshoptDecoder.d.cts

@@ -0,0 +1,12 @@
+type API = {
+    ready: Promise<void>;
+    supported: boolean;
+    decodeVertexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, filter?: string) => void;
+    decodeIndexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
+    decodeIndexSequence: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
+    decodeGltfBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string) => void;
+};
+declare const MeshoptDecoder: () => API | {
+    supported: boolean;
+};
+export { type MeshoptDecoder };

package/libs/MeshoptDecoder.d.ts

@@ -9,4 +9,4 @@ type API = {
 declare const MeshoptDecoder: () => API | {
     supported: boolean;
 };
-export { MeshoptDecoder };
+export { type MeshoptDecoder };

package/libs/MotionControllers.d.cts

@@ -0,0 +1,176 @@
+/**
+ * @webxr-input-profiles/motion-controllers 1.0.0 https://github.com/immersive-web/webxr-input-profiles
+ */
+/// <reference types="webxr" />
+import type { Object3D } from 'three';
+interface GamepadIndices {
+    button: number;
+    xAxis?: number;
+    yAxis?: number;
+}
+interface VisualResponseDescription {
+    componentProperty: string;
+    states: string[];
+    valueNodeProperty: string;
+    valueNodeName: string;
+    minNodeName?: string;
+    maxNodeName?: string;
+}
+type VisualResponses = Record<string, VisualResponseDescription>;
+interface ComponentDescription {
+    type: string;
+    gamepadIndices: GamepadIndices;
+    rootNodeName: string;
+    visualResponses: VisualResponses;
+    touchPointNodeName?: string;
+}
+interface Components {
+    [componentKey: string]: ComponentDescription;
+}
+interface LayoutDescription {
+    selectComponentId: string;
+    components: Components;
+    gamepadMapping: string;
+    rootNodeName: string;
+    assetPath: string;
+}
+type Layouts = Partial<Record<XRHandedness, LayoutDescription>>;
+export interface Profile {
+    profileId: string;
+    fallbackProfileIds: string[];
+    layouts: Layouts;
+}
+interface ProfilesList {
+    [profileId: string]: {
+        path: string;
+        deprecated?: boolean;
+    } | undefined;
+}
+declare const MotionControllerConstants: {
+    Handedness: {
+        NONE: string;
+        LEFT: string;
+        RIGHT: string;
+    };
+    ComponentState: {
+        DEFAULT: string;
+        TOUCHED: string;
+        PRESSED: string;
+    };
+    ComponentProperty: {
+        BUTTON: string;
+        X_AXIS: string;
+        Y_AXIS: string;
+        STATE: string;
+    };
+    ComponentType: {
+        TRIGGER: string;
+        SQUEEZE: string;
+        TOUCHPAD: string;
+        THUMBSTICK: string;
+        BUTTON: string;
+    };
+    ButtonTouchThreshold: number;
+    AxisTouchThreshold: number;
+    VisualResponseProperty: {
+        TRANSFORM: string;
+        VISIBILITY: string;
+    };
+};
+declare function fetchProfilesList(basePath: string): Promise<ProfilesList>;
+declare function fetchProfile(xrInputSource: XRInputSource, basePath: string, defaultProfile?: string | null, getAssetPath?: boolean): Promise<{
+    profile: Profile;
+    assetPath: string | undefined;
+}>;
+/**
+ * Contains the description of how the 3D model should visually respond to a specific user input.
+ * This is accomplished by initializing the object with the name of a node in the 3D model and
+ * property that need to be modified in response to user input, the name of the nodes representing
+ * the allowable range of motion, and the name of the input which triggers the change. In response
+ * to the named input changing, this object computes the appropriate weighting to use for
+ * interpolating between the range of motion nodes.
+ */
+declare class VisualResponse implements VisualResponseDescription {
+    value: number | boolean;
+    componentProperty: string;
+    states: string[];
+    valueNodeName: string;
+    valueNodeProperty: string;
+    minNodeName?: string;
+    maxNodeName?: string;
+    valueNode: Object3D | undefined;
+    minNode: Object3D | undefined;
+    maxNode: Object3D | undefined;
+    constructor(visualResponseDescription: VisualResponseDescription);
+    /**
+     * Computes the visual response's interpolation weight based on component state
+     * @param {Object} componentValues - The component from which to update
+     * @param {number | undefined} xAxis - The reported X axis value of the component
+     * @param {number | undefined} yAxis - The reported Y axis value of the component
+     * @param {number | undefined} button - The reported value of the component's button
+     * @param {string} state - The component's active state
+     */
+    updateFromComponent({ xAxis, yAxis, button, state, }: {
+        xAxis?: number;
+        yAxis?: number;
+        button?: number;
+        state: string;
+    }): void;
+}
+declare class Component implements ComponentDescription {
+    id: string;
+    values: {
+        state: string;
+        button: number | undefined;
+        xAxis: number | undefined;
+        yAxis: number | undefined;
+    };
+    type: string;
+    gamepadIndices: GamepadIndices;
+    rootNodeName: string;
+    visualResponses: Record<string, VisualResponse>;
+    touchPointNodeName?: string | undefined;
+    touchPointNode?: Object3D;
+    /**
+     * @param {string} componentId - Id of the component
+     * @param {InputProfileComponent} componentDescription - Description of the component to be created
+     */
+    constructor(componentId: string, componentDescription: ComponentDescription);
+    get data(): {
+        id: Component['id'];
+    } & Component['values'];
+    /**
+     * @description Poll for updated data based on current gamepad state
+     * @param {Object} gamepad - The gamepad object from which the component data should be polled
+     */
+    updateFromGamepad(gamepad: Gamepad): void;
+}
+/**
+ * @description Builds a motion controller with components and visual responses based on the
+ * supplied profile description. Data is polled from the xrInputSource's gamepad.
+ * @author Nell Waliczek / https://github.com/NellWaliczek
+ */
+declare class MotionController {
+    xrInputSource: XRInputSource;
+    assetUrl: string;
+    layoutDescription: LayoutDescription;
+    id: string;
+    components: Record<string, Component>;
+    /**
+     * @param {XRInputSource} xrInputSource - The XRInputSource to build the MotionController around
+     * @param {Profile} profile - The best matched profile description for the supplied xrInputSource
+     * @param {string} assetUrl
+     */
+    constructor(xrInputSource: XRInputSource, profile: Profile, assetUrl: string);
+    get gripSpace(): XRInputSource['gripSpace'];
+    get targetRaySpace(): XRInputSource['targetRaySpace'];
+    /**
+     * @description Returns a subset of component data for simplified debugging
+     */
+    get data(): Array<Component['data']>;
+    /**
+     * @description Poll for updated data based on current gamepad state
+     */
+    updateFromGamepad(): void;
+}
+export { type MotionControllerConstants, MotionController, fetchProfile, fetchProfilesList };

package/libs/MotionControllers.d.ts

@@ -173,4 +173,4 @@ declare class MotionController {
      */
     updateFromGamepad(): void;
 }
-export { MotionControllerConstants, MotionController, fetchProfile, fetchProfilesList };
+export { type MotionControllerConstants, MotionController, fetchProfile, fetchProfilesList };

package/libs/zstddec.d.cts

@@ -0,0 +1,8 @@
+/**
+ * ZSTD (Zstandard) decoder.
+ */
+export declare class ZSTDDecoder {
+    init(): Promise<void>;
+    _init(result: WebAssembly.WebAssemblyInstantiatedSource): void;
+    decode(array: Uint8Array, uncompressedSize?: number): Uint8Array;
+}

package/lights/LightProbeGenerator.d.cts

@@ -0,0 +1,6 @@
+import type { CubeTexture, LightProbe, WebGLRenderer, WebGLCubeRenderTarget } from 'three'
+
+export namespace LightProbeGenerator {
+  function fromCubeTexture(cubeTexture: CubeTexture): LightProbe
+  function fromCubeRenderTarget(renderer: WebGLRenderer, cubeRenderTarget: WebGLCubeRenderTarget): LightProbe
+}

package/lights/LightProbeGenerator.d.ts

@@ -1,4 +1,4 @@
-import { CubeTexture, LightProbe, WebGLRenderer, WebGLCubeRenderTarget } from 'three'
+import type { CubeTexture, LightProbe, WebGLRenderer, WebGLCubeRenderTarget } from 'three'
 
 export namespace LightProbeGenerator {
   function fromCubeTexture(cubeTexture: CubeTexture): LightProbe

package/lights/RectAreaLightUniformsLib.d.cts

@@ -0,0 +1,3 @@
+export namespace RectAreaLightUniformsLib {
+  function init(): void
+}

package/lines/Line2.d.cts

@@ -0,0 +1,11 @@
+import type { LineGeometry } from './LineGeometry.d.cts'
+import type { LineSegments2 } from './LineSegments2.d.cts'
+import type { LineMaterial } from './LineMaterial.d.cts'
+
+export class Line2 extends LineSegments2 {
+  geometry: LineGeometry
+  material: LineMaterial
+
+  constructor(geometry?: LineGeometry, material?: LineMaterial)
+  readonly isLine2: true
+}

package/lines/Line2.d.ts

@@ -1,6 +1,6 @@
-import { LineGeometry } from './LineGeometry'
-import { LineSegments2 } from './LineSegments2'
-import { LineMaterial } from './LineMaterial'
+import type { LineGeometry } from './LineGeometry.d.ts'
+import type { LineSegments2 } from './LineSegments2.d.ts'
+import type { LineMaterial } from './LineMaterial.d.ts'
 
 export class Line2 extends LineSegments2 {
   geometry: LineGeometry

package/lines/LineGeometry.d.cts

@@ -0,0 +1,10 @@
+import type { Line } from 'three'
+
+import type { LineSegmentsGeometry } from './LineSegmentsGeometry.d.cts'
+
+export class LineGeometry extends LineSegmentsGeometry {
+  constructor()
+  readonly isLineGeometry: true
+
+  fromLine(line: Line): this
+}

package/lines/LineGeometry.d.ts

@@ -1,6 +1,6 @@
-import { Line } from 'three'
+import type { Line } from 'three'
 
-import { LineSegmentsGeometry } from './LineSegmentsGeometry'
+import type { LineSegmentsGeometry } from './LineSegmentsGeometry.d.ts'
 
 export class LineGeometry extends LineSegmentsGeometry {
   constructor()

package/lines/LineMaterial.d.cts

@@ -0,0 +1,31 @@
+import type { Color, MaterialParameters, ShaderMaterial, Vector2 } from 'three'
+
+export interface LineMaterialParameters extends MaterialParameters {
+  alphaToCoverage?: boolean | undefined
+  color?: number | undefined
+  dashed?: boolean | undefined
+  dashScale?: number | undefined
+  dashSize?: number | undefined
+  dashOffset?: number | undefined
+  gapSize?: number | undefined
+  linewidth?: number | undefined
+  resolution?: Vector2 | undefined
+  wireframe?: boolean | undefined
+  worldUnits?: boolean | undefined
+}
+
+export class LineMaterial extends ShaderMaterial {
+  constructor(parameters?: LineMaterialParameters)
+  color: Color
+  dashed: boolean
+  dashScale: number
+  dashSize: number
+  dashOffset: number
+  gapSize: number
+  opacity: number
+  readonly isLineMaterial: true
+  linewidth: number
+  resolution: Vector2
+  alphaToCoverage: boolean
+  worldUnits: boolean
+}

package/lines/LineMaterial.d.ts

@@ -1,4 +1,4 @@
-import { Color, MaterialParameters, ShaderMaterial, Vector2 } from 'three'
+import type { Color, MaterialParameters, ShaderMaterial, Vector2 } from 'three'
 
 export interface LineMaterialParameters extends MaterialParameters {
   alphaToCoverage?: boolean | undefined

package/lines/LineSegments2.d.cts

@@ -0,0 +1,14 @@
+import type { Mesh } from 'three'
+
+import type { LineMaterial } from './LineMaterial.d.cts'
+import type { LineSegmentsGeometry } from './LineSegmentsGeometry.d.cts'
+
+export class LineSegments2 extends Mesh {
+  geometry: LineSegmentsGeometry
+  material: LineMaterial
+
+  constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial)
+  readonly isLineSegments2: true
+
+  computeLineDistances(): this
+}

package/lines/LineSegments2.d.ts

@@ -1,7 +1,7 @@
-import { Mesh } from 'three'
+import type { Mesh } from 'three'
 
-import { LineMaterial } from './LineMaterial'
-import { LineSegmentsGeometry } from './LineSegmentsGeometry'
+import type { LineMaterial } from './LineMaterial.d.ts'
+import type { LineSegmentsGeometry } from './LineSegmentsGeometry.d.ts'
 
 export class LineSegments2 extends Mesh {
   geometry: LineSegmentsGeometry

package/lines/LineSegmentsGeometry.d.cts

@@ -0,0 +1,16 @@
+import type { EdgesGeometry, InstancedBufferGeometry, LineSegments, Matrix4, Mesh, WireframeGeometry } from 'three'
+
+export class LineSegmentsGeometry extends InstancedBufferGeometry {
+  constructor()
+  readonly isLineSegmentsGeometry: true
+
+  applyMatrix4(matrix: Matrix4): this
+  computeBoundingBox(): void
+  computeBoundingSphere(): void
+  fromEdgesGeometry(geometry: EdgesGeometry): this
+  fromLineSegments(lineSegments: LineSegments): this
+  fromMesh(mesh: Mesh): this
+  fromWireframeGeometry(geometry: WireframeGeometry): this
+  setColors(array: number[] | Float32Array, itemSize?: 3 | 4): this
+  setPositions(array: number[] | Float32Array): this
+}

package/lines/LineSegmentsGeometry.d.ts

@@ -1,4 +1,4 @@
-import { EdgesGeometry, InstancedBufferGeometry, LineSegments, Matrix4, Mesh, WireframeGeometry } from 'three'
+import type { EdgesGeometry, InstancedBufferGeometry, LineSegments, Matrix4, Mesh, WireframeGeometry } from 'three'
 
 export class LineSegmentsGeometry extends InstancedBufferGeometry {
   constructor()

package/lines/Wireframe.d.cts

@@ -0,0 +1,11 @@
+import type { Mesh } from 'three'
+
+import type { LineMaterial } from './LineMaterial.d.cts'
+import type { LineSegmentsGeometry } from './LineSegmentsGeometry.d.cts'
+
+export class Wireframe extends Mesh {
+  constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial)
+  readonly isWireframe: true
+
+  computeLineDistances(): this
+}

package/lines/Wireframe.d.ts

@@ -1,7 +1,7 @@
-import { Mesh } from 'three'
+import type { Mesh } from 'three'
 
-import { LineMaterial } from './LineMaterial'
-import { LineSegmentsGeometry } from './LineSegmentsGeometry'
+import type { LineMaterial } from './LineMaterial.d.ts'
+import type { LineSegmentsGeometry } from './LineSegmentsGeometry.d.ts'
 
 export class Wireframe extends Mesh {
   constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial)

package/lines/WireframeGeometry2.d.cts

@@ -0,0 +1,8 @@
+import type { BufferGeometry } from 'three'
+
+import type { LineSegmentsGeometry } from './LineSegmentsGeometry.d.cts'
+
+export class WireframeGeometry2 extends LineSegmentsGeometry {
+  constructor(geometry: BufferGeometry)
+  readonly sWireframeGeometry2: boolean
+}

package/lines/WireframeGeometry2.d.ts

@@ -1,6 +1,6 @@
-import { BufferGeometry } from 'three'
+import type { BufferGeometry } from 'three'
 
-import { LineSegmentsGeometry } from './LineSegmentsGeometry'
+import type { LineSegmentsGeometry } from './LineSegmentsGeometry.d.ts'
 
 export class WireframeGeometry2 extends LineSegmentsGeometry {
   constructor(geometry: BufferGeometry)

package/loaders/3DMLoader.d.cts

@@ -0,0 +1,17 @@
+import type { Loader, LoadingManager, Object3D } from 'three'
+
+export class Rhino3dmLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (object: Object3D) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Object3D>
+  parse(data: ArrayBufferLike, onLoad: (object: Object3D) => void, onError?: (event: ErrorEvent) => void): void
+  setLibraryPath(path: string): Rhino3dmLoader
+  setWorkerLimit(workerLimit: number): Rhino3dmLoader
+  dispose(): Rhino3dmLoader
+}

package/loaders/3DMLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Object3D } from 'three'
+import type { Loader, LoadingManager, Object3D } from 'three'
 
 export class Rhino3dmLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/3MFLoader.d.cts

@@ -0,0 +1,16 @@
+import type { Loader, LoadingManager, Group } from 'three'
+
+export class ThreeMFLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  availableExtensions: object[]
+
+  load(
+    url: string,
+    onLoad: (object: Group) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
+  parse(data: ArrayBuffer): Group
+  addExtension(extension: object): void
+}

package/loaders/3MFLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Group } from 'three'
+import type { Loader, LoadingManager, Group } from 'three'
 
 export class ThreeMFLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/AMFLoader.d.cts

@@ -0,0 +1,14 @@
+import type { Loader, LoadingManager, Group } from 'three'
+
+export class AMFLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (object: Group) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
+  parse(data: ArrayBuffer): Group
+}

package/loaders/AMFLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Group } from 'three'
+import type { Loader, LoadingManager, Group } from 'three'
 
 export class AMFLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/AssimpLoader.d.cts

@@ -0,0 +1,19 @@
+import type { Loader, Object3D, LoadingManager } from 'three'
+
+export interface Assimp {
+  animation: any
+  object: Object3D
+}
+
+export class AssimpLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (result: Assimp) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Assimp>
+  parse(buffer: ArrayBuffer, path: string): Assimp
+}

package/loaders/AssimpLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, Object3D, LoadingManager } from 'three'
+import type { Loader, Object3D, LoadingManager } from 'three'
 
 export interface Assimp {
   animation: any

package/loaders/BVHLoader.d.cts

@@ -0,0 +1,21 @@
+import type { Loader, AnimationClip, Skeleton, LoadingManager } from 'three'
+
+export interface BVH {
+  clip: AnimationClip
+  skeleton: Skeleton
+}
+
+export class BVHLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  animateBonePositions: boolean
+  animateBoneRotations: boolean
+
+  load(
+    url: string,
+    onLoad: (bvh: BVH) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BVH>
+  parse(text: string): BVH
+}

package/loaders/BVHLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, AnimationClip, Skeleton, LoadingManager } from 'three'
+import type { Loader, AnimationClip, Skeleton, LoadingManager } from 'three'
 
 export interface BVH {
   clip: AnimationClip

package/loaders/BasisTextureLoader.d.cts

@@ -0,0 +1,32 @@
+import type { Loader, CompressedTexture, LoadingManager, WebGLRenderer } from 'three'
+
+export class BasisTextureLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  transcoderBinary: ArrayBuffer | null
+  transcoderPath: string
+  transcoderPending: Promise<void> | null
+
+  workerConfig: {
+    format: number
+    astcSupported: boolean
+    etcSupported: boolean
+    dxtSupported: boolean
+    pvrtcSupported: boolean
+  }
+  workerLimit: number
+  workerNextTaskID: number
+  workerPool: object[]
+  workerSourceURL: string
+
+  detectSupport(renderer: WebGLRenderer): this
+  load(
+    url: string,
+    onLoad: (texture: CompressedTexture) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CompressedTexture>
+  setTranscoderPath(path: string): this
+  setWorkerLimit(workerLimit: number): this
+  dispose(): void
+}

package/loaders/BasisTextureLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, CompressedTexture, LoadingManager, WebGLRenderer } from 'three'
+import type { Loader, CompressedTexture, LoadingManager, WebGLRenderer } from 'three'
 
 export class BasisTextureLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/ColladaLoader.d.cts

@@ -0,0 +1,20 @@
+import type { Loader, LoadingManager, Scene } from 'three'
+
+export interface Collada {
+  kinematics: object
+  library: object
+  scene: Scene
+}
+
+export class ColladaLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (collada: Collada) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>
+  parse(text: string, path: string): Collada
+}

package/loaders/ColladaLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Scene } from 'three'
+import type { Loader, LoadingManager, Scene } from 'three'
 
 export interface Collada {
   kinematics: object

package/loaders/DDSLoader.d.cts

@@ -0,0 +1,16 @@
+import type { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from 'three'
+
+export interface DDS {
+  mipmaps: object[]
+  width: number
+  height: number
+  format: PixelFormat | CompressedPixelFormat
+  mipmapCount: number
+  isCubemap: boolean
+}
+
+export class DDSLoader extends CompressedTextureLoader {
+  constructor(manager?: LoadingManager)
+
+  parse(buffer: ArrayBuffer, loadMipmaps: boolean): DDS
+}

package/loaders/DDSLoader.d.ts

@@ -1,4 +1,4 @@
-import { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from 'three'
+import type { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from 'three'
 
 export interface DDS {
   mipmaps: object[]

package/loaders/DRACOLoader.d.cts

@@ -0,0 +1,18 @@
+import type { Loader, LoadingManager, BufferGeometry } from 'three'
+
+export class DRACOLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (geometry: BufferGeometry) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>
+  setDecoderPath(path: string): DRACOLoader
+  setDecoderConfig(config: object): DRACOLoader
+  setWorkerLimit(workerLimit: number): DRACOLoader
+  preload(): DRACOLoader
+  dispose(): DRACOLoader
+}