@types/three 0.180.0 → 0.182.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Wed, 03 Sep 2025 18:38:35 GMT
+ * Last updated: Wed, 10 Dec 2025 22:36:27 GMT
  * Dependencies: [@dimforge/rapier3d-compat](https://npmjs.com/package/@dimforge/rapier3d-compat), [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/controls/ArcballControls.d.ts

@@ -130,7 +130,7 @@ declare class ArcballControls extends Controls<ArcballControlsEventMap> {
      * @param domElement The HTML element used for event listeners. (optional)
      * @param scene The scene rendered by the camera. If not given, gizmos cannot be shown. (optional)
      */
-    constructor(camera: Camera, domElement?: HTMLElement | null, scene?: Scene | null);
+    constructor(camera: Camera, domElement?: HTMLElement | SVGElement | null, scene?: Scene | null);
 
     /**
      * Set a new mouse action by specifying the operation to be performed and a mouse/key combination. In case of

three/examples/jsm/controls/DragControls.d.ts

@@ -75,7 +75,7 @@ declare class DragControls extends Controls<DragControlsEventMap> {
      * @param camera The camera of the rendered scene.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(objects: Object3D[], camera: Camera, domElement?: HTMLElement | null);
+    constructor(objects: Object3D[], camera: Camera, domElement?: HTMLElement | SVGElement | null);
 }
 
 export { DragControls };

three/examples/jsm/controls/FirstPersonControls.d.ts

@@ -76,7 +76,7 @@ declare class FirstPersonControls extends Controls<{}> {
      * @param object The camera to be controlled.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(object: Camera, domElement?: HTMLElement);
+    constructor(object: Camera, domElement?: HTMLElement | SVGElement);
 
     /**
      * Should be called if the application window is resized.

three/examples/jsm/controls/FlyControls.d.ts

@@ -38,7 +38,7 @@ declare class FlyControls extends Controls<FlyControlsEventMap> {
      * @param object The camera to be controlled.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(object: Camera, domElement?: HTMLElement | null);
+    constructor(object: Camera, domElement?: HTMLElement | SVGElement | null);
 }
 
 export { FlyControls };

three/examples/jsm/controls/OrbitControls.d.ts

@@ -206,7 +206,7 @@ declare class OrbitControls extends Controls<OrbitControlsEventMap> {
      * is the scene itself.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(object: Camera, domElement?: HTMLElement | null);
+    constructor(object: Camera, domElement?: HTMLElement | SVGElement | null);
 
     /**
      * Get the current vertical rotation, in radians.

three/examples/jsm/controls/PointerLockControls.d.ts

@@ -47,7 +47,7 @@ declare class PointerLockControls extends Controls<PointerLockControlsEventMap>
      * @param camera The camera of the rendered scene.
      * @param domElement The HTML element used for event listeners.
      */
-    constructor(camera: Camera, domElement?: HTMLElement | null);
+    constructor(camera: Camera, domElement?: HTMLElement | SVGElement | null);
 
     /**
      * Returns the look direction of the camera.

three/examples/jsm/controls/TrackballControls.d.ts

@@ -124,7 +124,7 @@ declare class TrackballControls extends Controls<TrackballControlsEventMap> {
      * @param camera The camera of the rendered scene.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(camera: Camera, domElement?: HTMLElement | null);
+    constructor(camera: Camera, domElement?: HTMLElement | SVGElement | null);
 
     /**
      * Should be called if the application window is resized.

three/examples/jsm/controls/TransformControls.d.ts

@@ -163,7 +163,7 @@ declare class TransformControls extends Controls<TransformControlsEventMap> {
      * @param camera The camera of the rendered scene.
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(camera: Camera, domElement?: HTMLElement);
+    constructor(camera: Camera, domElement?: HTMLElement | SVGElement | null);
 
     /**
      * Returns the visual representation of the controls. Add the helper to your scene to visually transform the

three/examples/jsm/geometries/TextGeometry.d.ts

@@ -59,6 +59,8 @@ export interface TextGeometryParameters extends ExtrudeGeometryOptions {
      * @defaultValue `3`
      */
     bevelSegments?: number | undefined;
+
+    direction?: "ltr" | "rtl" | "tb" | undefined;
 }
 
 /**

three/examples/jsm/gpgpu/BitonicSort.d.ts

@@ -0,0 +1,21 @@
+import { Node, Renderer, StorageBufferNode } from "three/webgpu";
+
+export const getBitonicFlipIndices: (index: Node, blockHeight: Node) => Node;
+
+export const getBitonicDisperseIndices: (index: Node, swapSpan: Node) => Node;
+
+export interface BitonicSortOptions {
+    workgroupSize?: number | undefined;
+}
+
+export class BitonicSort {
+    infoStorage: StorageBufferNode;
+
+    swapOpCount: number;
+    stepCount: number;
+
+    constructor(renderer: Renderer, dataBuffer: StorageBufferNode, options?: BitonicSortOptions);
+
+    computeStep(renderer: Renderer): Promise<void>;
+    compute(renderer: Renderer): Promise<void>;
+}

three/examples/jsm/inspector/Inspector.d.ts

@@ -0,0 +1,10 @@
+import { RendererInspector } from "./RendererInspector.js";
+import { ParametersGroup } from "./tabs/Parameters.js";
+
+declare class Inspector extends RendererInspector {
+    createParameters(name: string): ParametersGroup;
+
+    get domElement(): HTMLDivElement;
+}
+
+export { Inspector };

three/examples/jsm/inspector/RendererInspector.d.ts

@@ -0,0 +1,4 @@
+import { InspectorBase } from "three/webgpu";
+
+export class RendererInspector extends InspectorBase {
+}

three/examples/jsm/inspector/tabs/Parameters.d.ts

@@ -0,0 +1,95 @@
+import { Tab } from "../ui/Tab.js";
+import { ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider } from "../ui/Values.js";
+
+type KeyToValueOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+
+interface ValueSelectWithParameters<T = Record<string, unknown>, K extends keyof T = keyof T>
+    extends ValueSelect<T, K>
+{
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueNumberWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends ValueNumber<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueSliderWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends ValueSlider<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueCheckboxWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, boolean> = KeyToValueOfType<T, boolean>,
+> extends ValueCheckbox<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueButtonWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, (this: T) => void> = KeyToValueOfType<T, (this: T) => void>,
+> extends ValueButton<T, K> {
+    name: (name: string) => this;
+}
+
+interface ValueColorWithParameters<
+    T = Record<string, unknown>,
+    K extends keyof T = keyof T,
+> extends ValueColor<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+declare class ParametersGroup {
+    name: string;
+
+    constructor(parameters: never, name: string);
+
+    add<T, K extends keyof T>(
+        object: T,
+        property: K,
+        options: ReadonlyArray<T[K]> | Record<string, T[K]>,
+    ): ValueSelectWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, number>>(
+        object: T,
+        property: K,
+        min: number,
+        max: number,
+        step?: number,
+    ): ValueSliderWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, number>>(
+        object: T,
+        property: K,
+        min?: number,
+    ): ValueNumberWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, boolean>>(
+        object: T,
+        property: K,
+        options?: never,
+    ): ValueCheckboxWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, (this: T) => void>>(
+        object: T,
+        property: K,
+        options?: never,
+    ): ValueButtonWithParameters<T, K>;
+
+    addFolder(name: string): ParametersGroup;
+
+    addColor<T, K extends keyof T>(object: T, property: K, rgbScale?: number): ValueColorWithParameters<T, K>;
+}
+
+declare class Parameters extends Tab {
+    createGroup(name: string): ParametersGroup;
+}
+
+export { Parameters };
+export type { ParametersGroup };

three/examples/jsm/inspector/ui/Tab.d.ts

@@ -0,0 +1,3 @@
+export class Tab {
+    constructor(title: string);
+}

three/examples/jsm/inspector/ui/Values.d.ts

@@ -0,0 +1,80 @@
+import { ColorRepresentation, EventDispatcher } from "three";
+
+type KeyToValueOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+
+declare class Value<T = Record<string, unknown>, K extends keyof T = keyof T> extends EventDispatcher {
+    onChange(callback: (value: T[K]) => void): this;
+}
+
+export interface ValueNumberParams {
+    value?: number;
+    step?: number;
+    min?: number;
+    max?: number;
+}
+
+declare class ValueNumber<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends Value<T, K> {
+    constructor(params: ValueNumberParams);
+}
+
+export interface ValueCheckboxParams {
+    value?: boolean;
+}
+
+declare class ValueCheckbox<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, boolean> = KeyToValueOfType<T, boolean>,
+> extends Value<T, K> {
+    constructor(params: ValueCheckboxParams);
+}
+
+export interface ValueSliderParams {
+    value?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+
+declare class ValueSlider<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends Value<T, K> {
+    constructor(params: ValueSliderParams);
+
+    setValue(val: number): this;
+    step(value: number): this;
+}
+
+export interface ValueSelectParams<T, K extends keyof T> {
+    options?: ReadonlyArray<T[K]> | Record<string, T[K]>;
+    value?: number;
+}
+
+declare class ValueSelect<T = Record<string, unknown>, K extends keyof T = keyof T> extends Value<T, K> {
+    constructor(params: ValueSelectParams<T, K>);
+}
+
+export interface ValueColorParams {
+    value?: ColorRepresentation;
+}
+
+declare class ValueColor<T = Record<string, unknown>, K extends keyof T = keyof T> extends Value<T, K> {
+    constructor(params: ValueColorParams);
+}
+
+export interface ValueButtonParams {
+    text?: string;
+    value?: () => void;
+}
+
+declare class ValueButton<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, (this: T) => void> = KeyToValueOfType<T, (this: T) => void>,
+> extends Value<T, K> {
+    constructor(params: ValueColorParams);
+}
+
+export { Value, ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider };

three/examples/jsm/interactive/SelectionBox.d.ts

@@ -1,16 +1,16 @@
-import { Camera, Frustum, Mesh, Object3D, Scene, Vector3 } from "three";
+import { Camera, Object3D, Scene, Vector3 } from "three";
 
-export class SelectionBox {
-    constructor(camera: Camera, scene: Scene, deep?: number);
+declare class SelectionBox {
     camera: Camera;
-    collection: Mesh[];
-    deep: number;
-    endPoint: Vector3;
     scene: Scene;
     startPoint: Vector3;
+    endPoint: Vector3;
+    collection: Object3D[];
     instances: Record<string, number[]>;
+    batches: Record<string, number[]>;
+    deep: number;
+
+    constructor(camera: Camera, scene: Scene, deep?: number);
 
-    select(startPoint?: Vector3, endPoint?: Vector3): Mesh[];
-    updateFrustum(startPoint: Vector3, endPoint: Vector3): void;
-    searchChildInFrustum(frustum: Frustum, object: Object3D): void;
+    select(startPoint?: Vector3, endPoint?: Vector3): Object3D[];
 }

three/examples/jsm/lighting/TiledLighting.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Lighting } from "three/webgpu";
 import { Light } from "../../../src/lights/Light.js";
 import TiledLightsNode from "../tsl/lighting/TiledLightsNode.js";
@@ -6,5 +5,5 @@ import TiledLightsNode from "../tsl/lighting/TiledLightsNode.js";
 export class TiledLighting extends Lighting {
     constructor();
 
-    createNode(lights?: Light[]): ShaderNodeObject<TiledLightsNode>;
+    createNode(lights?: Light[]): TiledLightsNode;
 }

three/examples/jsm/loaders/FontLoader.d.ts

@@ -37,5 +37,5 @@ export class Font {
 
     constructor(data: FontData);
 
-    generateShapes(text: string, size?: number): Shape[];
+    generateShapes(text: string, size?: number, direction?: "ltr" | "rtl" | "tb"): Shape[];
 }

three/examples/jsm/loaders/KTX2Loader.d.ts

@@ -35,6 +35,9 @@ export class KTX2Loader extends Loader<CompressedTexture> {
      */
     setWorkerLimit(limit: number): this;
 
+    /**
+     * "detectSupportAsync()" has been deprecated. Use "detectSupport()" and "await renderer.init();" when creating the renderer.
+     */
     detectSupportAsync(renderer: Renderer): Promise<this>;
 
     /**

three/examples/jsm/loaders/UltraHDRLoader.d.ts

@@ -16,6 +16,13 @@ declare class UltraHDRLoader extends Loader<DataTexture> {
     setDataType(value: TextureDataType): this;
 
     parse(buffer: ArrayBuffer, onLoad: (texData: UltraHDRLoaderTextureData) => void): void;
+
+    load(
+        url: string,
+        onLoad: (data: DataTexture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): DataTexture;
 }
 
 export { UltraHDRLoader };

three/examples/jsm/loaders/VOXLoader.d.ts

@@ -1,4 +1,4 @@
-import { Data3DTexture, Loader, LoadingManager, Mesh } from "three";
+import { BufferGeometry, Data3DTexture, Loader, LoadingManager, Mesh, MeshStandardMaterial, Object3D } from "three";
 
 export interface Chunk {
     palette: number[];
@@ -6,16 +6,33 @@ export interface Chunk {
     data: Uint8Array;
 }
 
-export class VOXLoader extends Loader<Chunk[]> {
+export interface VOXLoaderResult {
+    chunks: Chunk[];
+    scene: Object3D;
+}
+
+declare class VOXLoader extends Loader<VOXLoaderResult> {
     constructor(manager?: LoadingManager);
 
-    parse(data: ArrayBuffer): object[];
+    parse(data: ArrayBuffer): VOXLoaderResult;
 }
 
-export class VOXMesh extends Mesh {
+declare function buildMesh(chunk: Chunk): Mesh<BufferGeometry, MeshStandardMaterial>;
+
+declare function buildData3DTexture(chunk: Chunk): Data3DTexture;
+
+/**
+ * @deprecated Use buildMesh() instead.
+ */
+declare class VOXMesh extends Mesh {
     constructor(chunk: Chunk);
 }
 
-export class VOXData3DTexture extends Data3DTexture {
+/**
+ * @deprecated Use buildData3DTexture() instead.
+ */
+declare class VOXData3DTexture extends Data3DTexture {
     constructor(chunk: Chunk);
 }
+
+export { buildData3DTexture, buildMesh, VOXData3DTexture, VOXLoader, VOXMesh };

three/examples/jsm/math/Octree.d.ts

@@ -1,32 +1,54 @@
-import { Box3, Layers, Object3D, Ray, Sphere, Triangle } from "three";
+import { Box3, Layers, Object3D, Ray, Sphere, Triangle, Vector3 } from "three";
 
 import { Capsule } from "./Capsule.js";
 
-export class Octree {
-    box: Box3 | null | undefined;
+interface OctreeTriangleIntersection {
+    normal: Vector3;
+    point: Vector3;
+    depth: number;
+}
+
+interface OctreeIntersection {
+    normal: Vector3;
+    depth: number;
+}
+
+interface OctreeRayIntersection {
+    distance: number;
+    triangle: Triangle;
+    position: Vector3;
+}
+
+declare class Octree {
+    box: Box3 | undefined;
     bounds: Box3;
 
-    subTrees: Octree[];
-    triangles: Triangle[];
     layers: Layers;
-
     trianglesPerLeaf: number;
     maxLevel: number;
 
-    constructor(box?: Box3 | null);
+    subTrees: Octree[];
+    triangles: Triangle[];
+
+    constructor(box?: Box3);
 
     addTriangle(triangle: Triangle): this;
     calcBox(): this;
     split(level: number): this;
     build(): this;
     getRayTriangles(ray: Ray, triangles: Triangle[]): Triangle[];
-    triangleCapsuleIntersect(capsule: Capsule, triangle: Triangle): any;
-    triangleSphereIntersect(sphere: Sphere, triangle: Triangle): any;
-    getSphereTriangles(sphere: Sphere, triangles: Triangle[]): Triangle[];
-    getCapsuleTriangles(capsule: Capsule, triangles: Triangle[]): Triangle[];
-    sphereIntersect(sphere: Sphere): any;
-    capsuleIntersect(capsule: Capsule): any;
-    rayIntersect(ray: Ray): any;
+    triangleCapsuleIntersect(capsule: Capsule, triangle: Triangle): OctreeTriangleIntersection | false;
+    triangleBoxIntersect(box: Box3, triangle: Triangle): OctreeTriangleIntersection | false;
+    triangleSphereIntersect(sphere: Sphere, triangle: Triangle): OctreeTriangleIntersection | false;
+    getSphereTriangles(sphere: Sphere, triangles: Triangle[]): void;
+    getBoxTriangles(box: Box3, triangles: Triangle[]): void;
+    getCapsuleTriangles(capsule: Capsule, triangles: Triangle[]): void;
+    boxIntersect(box: Box3): OctreeIntersection | false;
+    sphereIntersect(sphere: Sphere): OctreeIntersection | false;
+    capsuleIntersect(capsule: Capsule): OctreeIntersection | false;
+    rayIntersect(ray: Ray): OctreeRayIntersection | false;
     fromGraphNode(group: Object3D): this;
     clear(): this;
 }
+
+export { Octree };

three/examples/jsm/objects/SkyMesh.d.ts

@@ -1,16 +1,20 @@
-import { ShaderNodeObject } from "three/tsl";
 import { BoxGeometry, Mesh, NodeMaterial, UniformNode, Vector3 } from "three/webgpu";
 
 declare class SkyMesh extends Mesh<BoxGeometry, NodeMaterial> {
-    turbidity: ShaderNodeObject<UniformNode<number>>;
-    rayleigh: ShaderNodeObject<UniformNode<number>>;
-    mieCoefficient: ShaderNodeObject<UniformNode<number>>;
-    mieDirectionalG: ShaderNodeObject<UniformNode<number>>;
-    sunPosition: ShaderNodeObject<UniformNode<Vector3>>;
-    upUniform: ShaderNodeObject<UniformNode<Vector3>>;
+    turbidity: UniformNode<number>;
+    rayleigh: UniformNode<number>;
+    mieCoefficient: UniformNode<number>;
+    mieDirectionalG: UniformNode<number>;
+    sunPosition: UniformNode<Vector3>;
+    upUniform: UniformNode<Vector3>;
 
+    /**
+     * @deprecated
+     */
     readonly isSky: true;
 
+    readonly isSkyMesh: true;
+
     constructor();
 }
 

three/examples/jsm/objects/WaterMesh.d.ts

@@ -11,7 +11,7 @@ import {
 } from "three/webgpu";
 
 export interface WaterMeshOptions {
-    resolution?: number | undefined;
+    resolutionScale?: number | undefined;
     waterNormals: Texture;
     alpha?: number | undefined;
     size?: number | undefined;
@@ -24,7 +24,7 @@ export interface WaterMeshOptions {
 declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
     readonly isWater: true;
 
-    resolution: number;
+    resolutionScale: number;
 
     waterNormals: TextureNode;
     alpha: UniformNode<number>;

three/examples/jsm/physics/AmmoPhysics.d.ts

@@ -2,7 +2,7 @@ import { Mesh, Object3D, Vector3 } from "three";
 
 export interface AmmoPhysicsObject {
     addScene: (scene: Object3D) => void;
-    addMesh: (mesh: Mesh, mass?: number) => void;
+    addMesh: (mesh: Mesh, mass?: number, restitution?: number) => void;
     setMeshPosition: (mesh: Mesh, position: Vector3, index?: number) => void;
 }
 

three/examples/jsm/postprocessing/OutputPass.d.ts

@@ -1,10 +1,14 @@
-import { ShaderMaterial } from "three";
+import { IUniform, RawShaderMaterial } from "three";
 
-import { FullScreenQuad, Pass } from "./Pass.js";
+import { Pass } from "./Pass.js";
+
+declare class OutputPass extends Pass {
+    readonly isOutputPass: true;
+
+    uniforms: Record<string, IUniform>;
+    material: RawShaderMaterial;
 
-export class OutputPass extends Pass {
     constructor();
-    uniforms: object;
-    material: ShaderMaterial;
-    fsQuad: FullScreenQuad;
 }
+
+export { OutputPass };

three/examples/jsm/postprocessing/RenderPass.d.ts

@@ -2,15 +2,7 @@ import { Camera, Color, Material, Scene } from "three";
 
 import { Pass } from "./Pass.js";
 
-export class RenderPass extends Pass {
-    constructor(
-        scene: Scene,
-        camera: Camera,
-        overrideMaterial?: Material | null,
-        clearColor?: Color | null,
-        clearAlpha?: number | null,
-    );
-
+declare class RenderPass extends Pass {
     scene: Scene;
     camera: Camera;
 
@@ -18,6 +10,19 @@ export class RenderPass extends Pass {
 
     clearColor: Color | null;
     clearAlpha: number | null;
-
+    clear: boolean;
     clearDepth: boolean;
+    needsSwap: boolean;
+
+    readonly isRenderPass: true;
+
+    constructor(
+        scene: Scene,
+        camera: Camera,
+        overrideMaterial?: Material | null,
+        clearColor?: Color | null,
+        clearAlpha?: number | null,
+    );
 }
+
+export { RenderPass };

three/examples/jsm/renderers/CSS2DRenderer.d.ts

@@ -1,23 +1,28 @@
 import { Camera, Object3D, Scene, Vector2 } from "three";
 
-export class CSS2DObject extends Object3D {
-    constructor(element: HTMLElement);
+declare class CSS2DObject extends Object3D {
     element: HTMLElement;
     center: Vector2;
 
+    constructor(element: HTMLElement);
+
     onBeforeRender: (renderer: unknown, scene: Scene, camera: Camera) => void;
     onAfterRender: (renderer: unknown, scene: Scene, camera: Camera) => void;
 }
 
-export type CSS2DParameters = {
-    element?: HTMLElement;
-};
+export interface CSS2DParameters {
+    element?: HTMLElement | undefined;
+}
+
+declare class CSS2DRenderer {
+    domElement: HTMLElement;
+    sortObjects: boolean;
 
-export class CSS2DRenderer {
     constructor(parameters?: CSS2DParameters);
-    domElement: HTMLElement;
 
-    getSize(): { width: number; height: number };
-    setSize(width: number, height: number): void;
-    render(scene: Scene, camera: Camera): void;
+    getSize: () => { width: number; height: number };
+    render: (scene: Scene, camera: Camera) => void;
+    setSize: (width: number, height: number) => void;
 }
+
+export { CSS2DObject, CSS2DRenderer };