@types/three 0.184.0 → 0.185.0

three/examples/jsm/generators/city/SkyscraperGenerator.d.ts

@@ -0,0 +1,83 @@
+import { Color, Material, Mesh, MeshStandardNodeMaterial, Node } from "three/webgpu";
+
+export interface SkyscraperGeneratorDefaultParameters {
+    seed: number;
+    totalHeight: number;
+    floorHeight: number;
+    bayWidth: number;
+    stringCourseEvery: number;
+    chamferWidth: number;
+    chamferCornerX: number;
+    chamferCornerZ: number;
+    setbackDepth: number;
+    acChance: number;
+}
+
+export interface SkyscraperGeneratorParameters extends SkyscraperGeneratorDefaultParameters {
+    footprint: { width: number; depth: number };
+    tierFractions: { base: number; crown: number };
+    pierWidth: number;
+    pierDepth: number;
+    windowReveal: number;
+    stringCourseHeight: number;
+    archBayWidthRatio: number;
+    archRise: number;
+}
+
+/**
+ * Generates intricate, tripartite "Beaux-Arts / Neo-Gothic" terracotta
+ * skyscrapers from a small set of parameters.
+ *
+ * The mass is read as a footprint polygon (a rectangle with one chamfered
+ * corner) split into vertical faces, each split into three tiers — a tall
+ * arcaded base, a repeating shaft and an ornate crown — then into floors and
+ * bays. A handful of authored pieces (a pier, a window, a cornice profile, a
+ * gothic arch) are instanced across the whole tower, then baked — together with
+ * the bespoke base arcade — into a single non-indexed BufferGeometry tagged with
+ * a per-vertex `partId` ({@link PartId}) so one material can shade every zone.
+ *
+ * The generator is material agnostic — it only produces geometry. Pass a single
+ * material (e.g. a TSL node material that branches on `partId`) to dress it.
+ *
+ * ```js
+ * const generator = new SkyscraperGenerator( { seed: 35, totalHeight: 140 }, material );
+ * scene.add( generator.build() ); // a single Mesh
+ * ```
+ */
+export class SkyscraperGenerator {
+    constructor(parameters?: Partial<SkyscraperGeneratorParameters>, material?: Material);
+
+    parameters: Partial<SkyscraperGeneratorParameters>;
+    material: Material;
+
+    mesh: Mesh | null;
+
+    setParameters(parameters: Partial<SkyscraperGeneratorParameters>): this;
+    build(): Mesh;
+    rebuild(): Mesh;
+    dispose(): void;
+
+    static defaults: SkyscraperGeneratorDefaultParameters;
+}
+
+/**
+ * The facade material: a single MeshStandardNodeMaterial that reads the baked
+ * per-vertex `partId` and reproduces every zone — procedural terracotta brickwork
+ * on the walls and piers, smooth dressed stone on the window frames and ornament,
+ * dark glazing, and grey AC units — all dressed with world-space
+ * weathering. One material covers the whole building ( and a whole city ), which is
+ * what makes it compute-rasterizer friendly. `buildingBase` is the tower's flat
+ * masonry colour as a TSL node: pass a `uniform( Color )` for a single tower, or a
+ * per-fragment palette pick for a city, so the same material dresses both.
+ */
+export function createSkyscraperMaterial(buildingBase?: Node<"color"> | Color): MeshStandardNodeMaterial;
+
+/**
+ * The NYC masonry palette every tower is dressed from ( hex colours ): limestone-dominant
+ * with terracotta accents. Shared by the single-tower example and {@link CityGenerator}'s
+ * building material so both stay in sync.
+ */
+export const buildingPalette: number[];
+
+/** Picks one {@link buildingPalette} colour ( a hex number ) for a tower from its seed. */
+export function pickBuildingColor(seed: number): number;

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

@@ -0,0 +1,83 @@
+import { BufferGeometry, Vector3 } from "three";
+
+export interface LoftGeometryOptions {
+    closed?: boolean | undefined;
+    capStart?: boolean | undefined;
+    capEnd?: boolean | undefined;
+}
+
+export interface LoftGeometryParameters {
+    sections: Vector3[][];
+    closed: boolean;
+    capStart: boolean;
+    capEnd: boolean;
+}
+
+/**
+ * This class can be used to generate a geometry by lofting (skinning) a surface
+ * through a series of cross sections. Each section is an array of points in 3D
+ * space and all sections must have the same number of points.
+ *
+ * `LoftGeometry` is the general case of geometries like {@link LatheGeometry}
+ * (which revolves a fixed profile around an axis) or {@link TubeGeometry}
+ * (which sweeps a circular section along a path): the sections can have any
+ * shape, and can change shape, size, position and orientation from one
+ * section to the next.
+ *
+ * Sections wind around the loft so the resulting face normals point outwards
+ * when each section is ordered counterclockwise as seen from the end of the
+ * loft, looking back towards the start. If the surface appears inside out,
+ * reverse the point order of each section.
+ *
+ * ```js
+ * const sections = [];
+ *
+ * for ( let i = 0; i <= 10; i ++ ) {
+ *
+ * 	const points = [];
+ * 	const radius = 2 + Math.sin( i * 0.8 );
+ *
+ * 	for ( let j = 0; j < 32; j ++ ) {
+ *
+ * 		const angle = j / 32 * Math.PI * 2;
+ * 		points.push( new THREE.Vector3( Math.sin( angle ) * radius, i, Math.cos( angle ) * radius ) );
+ *
+ * 	}
+ *
+ * 	sections.push( points );
+ *
+ * }
+ *
+ * const geometry = new LoftGeometry( sections, { capStart: true, capEnd: true } );
+ * const material = new THREE.MeshStandardMaterial( { color: 0x00ff00 } );
+ * const mesh = new THREE.Mesh( geometry, material );
+ * scene.add( mesh );
+ * ```
+ *
+ * @augments BufferGeometry
+ * @three_import import { LoftGeometry } from 'three/addons/geometries/LoftGeometry.js';
+ */
+export class LoftGeometry extends BufferGeometry {
+    /**
+     * Constructs a new loft geometry.
+     *
+     * @param {Array<Array<Vector3>>} sections - The cross sections to skin. At least
+     * two sections are required and all sections must have the same number of points.
+     * @param {Object} [options={}] - The loft options.
+     * @param {boolean} [options.closed=true] - Whether each section is treated as a
+     * closed ring (e.g. a fuselage) or an open strip (e.g. a ribbon).
+     * @param {boolean} [options.capStart=false] - Whether the first section is closed
+     * with a cap or not.
+     * @param {boolean} [options.capEnd=false] - Whether the last section is closed
+     * with a cap or not.
+     */
+    constructor(sections?: Vector3[][], options?: LoftGeometryOptions);
+    /**
+     * Holds the constructor parameters that have been
+     * used to generate the geometry. Any modification
+     * after instantiation does not change the geometry.
+     *
+     * @type {Object}
+     */
+    parameters: LoftGeometryParameters;
+}

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

@@ -67,12 +67,15 @@ interface ValueColorWithParameters<
 }
 
 declare class ParametersGroup {
-    name: string;
-
     paramList: Item;
 
     constructor(parameters: never, name: string);
 
+    close(): this;
+    name(name: string): this;
+    show(): this;
+    hide(): this;
+
     add<T, K extends keyof T>(
         object: T,
         property: K,

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

@@ -0,0 +1,45 @@
+import { Light, Lighting } from "three/webgpu";
+import ClusteredLightsNode from "../tsl/lighting/ClusteredLightsNode.js";
+
+/**
+ * A custom lighting implementation based on Forward+ Clustered Shading that
+ * overwrites the default lighting system in {@link WebGPURenderer}. Suitable
+ * for 3D scenes with many point lights and real depth complexity — the view
+ * frustum is partitioned into a 3D cluster grid so only the lights actually
+ * reaching each fragment are evaluated.
+ *
+ * ```js
+ * const lighting = new ClusteredLighting();
+ * renderer.lighting = lighting; // set lighting system
+ * ```
+ *
+ * @augments Lighting
+ * @three_import import { ClusteredLighting } from 'three/addons/lighting/ClusteredLighting.js';
+ */
+export class ClusteredLighting extends Lighting {
+    maxLights: number;
+    tileSize: number;
+    zSlices: number;
+    maxLightsPerCluster: number;
+
+    /**
+     * Constructs a new clustered lighting system.
+     *
+     * @param {number} [maxLights=1024] - Maximum number of point lights.
+     * @param {number} [tileSize=32] - Screen tile size in pixels (cluster XY size).
+     * @param {number} [zSlices=24] - Number of exponential depth slices.
+     * @param {number} [maxLightsPerCluster=64] - Per-cluster light-list capacity.
+     */
+    constructor(maxLights?: number, tileSize?: number, zSlices?: number, maxLightsPerCluster?: number);
+
+    /**
+     * Creates a new clustered lights node for the given array of lights.
+     *
+     * This method is called internally by the renderer and must be overwritten by
+     * all custom lighting implementations.
+     *
+     * @param {Array<Light>} lights - The lights.
+     * @return {ClusteredLightsNode} The clustered lights node.
+     */
+    createNode(lights?: Light[]): ClusteredLightsNode;
+}

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

@@ -1,21 +1,66 @@
 import { Box3, Data3DTexture, Object3D, Scene, Vector3, WebGLRenderer } from "three";
 
 export interface LightProbeGridBakeOptions {
+    /**
+     * Resolution of each cubemap face.
+     */
     cubemapSize?: number | undefined;
+    /**
+     * Near plane for the cube camera.
+     */
     near?: number | undefined;
+    /**
+     * Far plane for the cube camera.
+     */
     far?: number | undefined;
+    /**
+     * Additional bounce passes after the initial direct pass.
+     */
+    bounces?: number | undefined;
 }
 
-declare class LightProbeGrid extends Object3D {
-    readonly isLightProbeGrid: boolean;
-
-    width: number;
-    height: number;
-    depth: number;
-    resolution: Vector3;
-    boundingBox: Box3;
-    texture: Data3DTexture | null;
-
+/**
+ * A 3D grid of L2 Spherical Harmonic irradiance probes that provides
+ * position-dependent diffuse global illumination.
+ *
+ * Note that this class can only be used with {@link WebGLRenderer}.
+ * A version for {@link WebGPURenderer} will be added at a later point.
+ *
+ * All seven packed SH sub-volumes are stored in a **single** RGBA
+ * `WebGL3DRenderTarget` using a texture-atlas layout along the Z axis.
+ * Each sub-volume occupies `( nz + 2 )` atlas slices: one padding slice at
+ * each end (a copy of the nearest edge data slice) to prevent color bleeding
+ * when the hardware trilinear filter reads across a sub-volume boundary.
+ *
+ * Atlas layout (nz = resolution.z, PADDING = 1):
+ * ```
+ *   slice   0              : padding  (copy of sub-volume 0, data slice 0)
+ *   slices  1 … nz         : sub-volume 0 data
+ *   slice   nz + 1         : padding  (copy of sub-volume 0, data slice nz-1)
+ *   slice   nz + 2         : padding  (copy of sub-volume 1, data slice 0)
+ *   slices  nz+3 … 2*nz+2  : sub-volume 1 data
+ *   …
+ * ```
+ * Total atlas depth = `7 * ( nz + 2 )`.
+ *
+ * Baking is fully GPU-resident: cubemap rendering, SH projection, and
+ * texture packing all happen on the GPU with zero CPU readback.
+ *
+ * @three_import import { LightProbeGrid } from 'three/addons/lighting/LightProbeGrid.js';
+ */
+export class LightProbeGrid extends Object3D {
+    /**
+     * Constructs a new irradiance probe grid.
+     *
+     * The volume is centered at the object's position.
+     *
+     * @param {number} [width=1] - Full width of the volume along X.
+     * @param {number} [height=1] - Full height of the volume along Y.
+     * @param {number} [depth=1] - Full depth of the volume along Z.
+     * @param {number} [widthProbes] - Number of probes along X. Defaults to `Math.max( 2, Math.round( width ) + 1 )`.
+     * @param {number} [heightProbes] - Number of probes along Y. Defaults to `Math.max( 2, Math.round( height ) + 1 )`.
+     * @param {number} [depthProbes] - Number of probes along Z. Defaults to `Math.max( 2, Math.round( depth ) + 1 )`.
+     */
     constructor(
         width?: number,
         height?: number,
@@ -24,11 +69,84 @@ declare class LightProbeGrid extends Object3D {
         heightProbes?: number,
         depthProbes?: number,
     );
-
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isLightProbeGrid: boolean;
+    /**
+     * The full width of the volume along X.
+     *
+     * @type {number}
+     */
+    width: number;
+    /**
+     * The full height of the volume along Y.
+     *
+     * @type {number}
+     */
+    height: number;
+    /**
+     * The full depth of the volume along Z.
+     *
+     * @type {number}
+     */
+    depth: number;
+    /**
+     * The number of probes along each axis.
+     *
+     * @type {Vector3}
+     */
+    resolution: Vector3;
+    /**
+     * The world-space bounding box for the grid. Updated automatically
+     * by {@link LightProbeGrid#bake}.
+     *
+     * @type {Box3}
+     */
+    boundingBox: Box3;
+    /**
+     * The single RGBA atlas 3D texture storing all seven packed SH sub-volumes.
+     *
+     * @type {?Data3DTexture}
+     * @default null
+     */
+    texture: Data3DTexture | null;
+    /**
+     * Returns the world-space position of the probe at grid indices (ix, iy, iz).
+     *
+     * @param {number} ix - X index.
+     * @param {number} iy - Y index.
+     * @param {number} iz - Z index.
+     * @param {Vector3} target - The target vector.
+     * @return {Vector3} The world-space position.
+     */
     getProbePosition(ix: number, iy: number, iz: number, target: Vector3): Vector3;
+    /**
+     * Updates the world-space bounding box from the current position and size.
+     */
     updateBoundingBox(): void;
+    /**
+     * Bakes all probes by rendering cubemaps at each probe position
+     * and projecting to L2 SH. Optionally iterates additional passes to
+     * capture indirect bounces — each extra pass samples the previous pass's
+     * atlas as indirect light, so a grid added to the scene before baking
+     * accumulates one bounce per extra pass.
+     *
+     * @param {WebGLRenderer} renderer - The renderer.
+     * @param {Scene} scene - The scene to render.
+     * @param {Object} [options] - Bake options.
+     * @param {number} [options.cubemapSize=8] - Resolution of each cubemap face.
+     * @param {number} [options.near=0.1] - Near plane for the cube camera.
+     * @param {number} [options.far=100] - Far plane for the cube camera.
+     * @param {number} [options.bounces=0] - Additional bounce passes after the initial direct pass.
+     */
     bake(renderer: WebGLRenderer, scene: Scene, options?: LightProbeGridBakeOptions): void;
+    /**
+     * Frees GPU resources.
+     */
     dispose(): void;
 }
-
-export { LightProbeGrid };

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

@@ -1,11 +1,23 @@
 import { BufferGeometry, Loader, LoadingManager } from "three";
 
-export class DRACOLoader extends Loader<BufferGeometry> {
+interface DecoderPaths {
+    js: string;
+    wasm: string;
+}
+
+declare const DRACO_GLTF_CONFIG: DecoderPaths;
+
+declare class DRACOLoader extends Loader<BufferGeometry> {
     constructor(manager?: LoadingManager);
 
-    setDecoderPath(path: string): DRACOLoader;
-    setDecoderConfig(config: object): DRACOLoader;
-    setWorkerLimit(workerLimit: number): DRACOLoader;
+    setDecoderPath(path: string | DecoderPaths): this;
+
+    /**
+     * @deprecated setDecoderConfig to has been deprecated and will be removed in r194.
+     */
+    setDecoderConfig(config: object): this;
+
+    setWorkerLimit(workerLimit: number): this;
 
     load(
         url: string,
@@ -20,6 +32,8 @@ export class DRACOLoader extends Loader<BufferGeometry> {
         onError?: (err: unknown) => void,
     ): void;
 
-    preload(): DRACOLoader;
-    dispose(): DRACOLoader;
+    preload(): this;
+    dispose(): this;
 }
+
+export { DRACO_GLTF_CONFIG, DRACOLoader };

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

@@ -1,25 +1,15 @@
 import {
     DataTextureLoader,
+    DataTextureLoaderTexData,
     FloatType,
     HalfFloatType,
     LoadingManager,
-    PixelFormat,
     RedFormat,
     RGBAFormat,
     RGFormat,
     TextureDataType,
 } from "three";
 
-export interface EXR {
-    header: object;
-    width: number;
-    height: number;
-    data: Float32Array | Uint16Array;
-    format: PixelFormat;
-    colorSpace: string;
-    type: typeof HalfFloatType | typeof FloatType;
-}
-
 declare class EXRLoader extends DataTextureLoader {
     type: TextureDataType;
     outputFormat: typeof RGBAFormat | typeof RGFormat | typeof RedFormat;
@@ -27,7 +17,7 @@ declare class EXRLoader extends DataTextureLoader {
 
     constructor(manager?: LoadingManager);
 
-    parse(buffer: ArrayBuffer): EXR;
+    parse(buffer: ArrayBuffer): DataTextureLoaderTexData;
     setDataType(type: typeof HalfFloatType | typeof FloatType): this;
     setOutputFormat(value: typeof RGBAFormat | typeof RGFormat | typeof RedFormat): this;
     setPart(value: number): this;

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

@@ -47,7 +47,7 @@ export class GLTFLoader extends Loader<GLTF> {
 
     constructor(manager?: LoadingManager);
 
-    setDRACOLoader(dracoLoader: DRACOLoader): this;
+    setDRACOLoader(dracoLoader: DRACOLoader | null): this;
     setKTX2Loader(ktx2Loader: KTX2Loader | null): this;
     setMeshoptDecoder(meshoptDecoder: typeof MeshoptDecoder | null): this;
 

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

@@ -1,21 +1,11 @@
-import { DataTextureLoader, LoadingManager, TextureDataType } from "three";
-
-export interface HDR {
-    width: number;
-    height: number;
-    data: Float32Array | Uint8Array;
-    header: string;
-    gamma: number;
-    exposure: number;
-    type: TextureDataType;
-}
+import { DataTextureLoader, DataTextureLoaderTexData, LoadingManager, TextureDataType } from "three";
 
 declare class HDRLoader extends DataTextureLoader {
     type: TextureDataType;
 
     constructor(manager?: LoadingManager);
 
-    parse(buffer: ArrayBuffer): HDR;
+    parse(buffer: ArrayBuffer): DataTextureLoaderTexData;
     setDataType(type: TextureDataType): this;
 }
 

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

@@ -54,5 +54,5 @@ export class KTX2Loader extends Loader<CompressedTexture> {
     /**
      * Disposes the loader object, de-allocating any Web Workers created.
      */
-    dispose(): this;
+    dispose(): void;
 }

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

@@ -12,7 +12,13 @@ export interface LWOLoaderParameters {
     resourcePath?: string;
 }
 
+/**
+ * @deprecated The loader has been deprecated and will be removed with r195. Export your LWO files to glTF before using them on the web.
+ */
 export class LWOLoader extends Loader<LWO> {
+    /**
+     * @deprecated The loader has been deprecated and will be removed with r195. Export your LWO files to glTF before using them on the web.
+     */
     constructor(manager?: LoadingManager, parameters?: LWOLoaderParameters);
 
     parse(data: ArrayBuffer, path: string, modelName: string): LWO;

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

@@ -1,10 +1,4 @@
-import { HDR, HDRLoader } from "./HDRLoader.js";
-
-/**
- * @deprecated RGBELoader has been deprecated. Please use HDRLoader instead.
- */
-export interface RGBE extends HDR {
-}
+import { HDRLoader } from "./HDRLoader.js";
 
 /**
  * @deprecated RGBELoader has been deprecated. Please use HDRLoader instead.

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

@@ -1,11 +1,7 @@
-import { BufferGeometry, Loader, LoadingManager, Shape, ShapePath, Vector2, Vector3 } from "three";
-
-export interface SVGResultPaths extends ShapePath {
-    userData?: Record<string, any> | undefined;
-}
+import { BufferGeometry, Loader, LoadingManager, MeshBasicMaterial, Shape, ShapePath, Vector2 } from "three";
 
 export interface SVGResult {
-    paths: SVGResultPaths[];
+    paths: ShapePath[];
     xml: XMLDocument;
 }
 
@@ -60,5 +56,12 @@ export class SVGLoader extends Loader<SVGResult> {
         vertexOffset?: number,
     ): number;
 
+    static createFillMaterial(shapePath: ShapePath): MeshBasicMaterial | null;
+
+    static createStrokeMaterial(shapePath: ShapePath): MeshBasicMaterial | null;
+
+    /**
+     * @deprecated Use shapePath.toShapes() instead.
+     */
     static createShapes(shapePath: ShapePath): Shape[];
 }

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

@@ -1,7 +1,7 @@
-import { DataTexture, DataTextureLoader, LoadingManager } from "three";
+import { DataTextureLoader, DataTextureLoaderTexData, LoadingManager } from "three";
 
 export class TGALoader extends DataTextureLoader {
     constructor(manager?: LoadingManager);
 
-    parse(data: ArrayBuffer): DataTexture;
+    parse(data: ArrayBuffer): DataTextureLoaderTexData;
 }

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

@@ -1,16 +1,7 @@
-import { DataTextureLoader, LoadingManager, TextureFilter } from "three";
-
-export interface TIFFResult {
-    width: number;
-    height: number;
-    data: Uint8Array;
-    flipY: true;
-    magFilter: TextureFilter;
-    minFilter: TextureFilter;
-}
+import { DataTextureLoader, DataTextureLoaderTexData, LoadingManager, TextureFilter } from "three";
 
 export class TIFFLoader extends DataTextureLoader {
     constructor(manager?: LoadingManager);
 
-    parse(buffer: Iterable<number>): TIFFResult;
+    parse(buffer: ArrayBuffer): DataTextureLoaderTexData;
 }

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

@@ -3,7 +3,12 @@ import { Group, Loader, LoadingManager } from "three";
 declare class USDLoader extends Loader<Group> {
     constructor(manager?: LoadingManager);
 
-    parse(buffer: ArrayBuffer | string): Group;
+    parse(
+        buffer: ArrayBuffer | string,
+        path?: string,
+        onLoad?: (group: Group) => void,
+        onError?: (err: unknown) => void,
+    ): Group;
 }
 
 export { USDLoader };

three/examples/jsm/misc/TileCreasedNormalsPlugin.d.ts

@@ -0,0 +1,49 @@
+import { Object3D } from "../../../src/core/Object3D.js";
+
+export interface TileCreasedNormalsPluginOptions {
+    creaseAngle?: number | undefined;
+}
+
+/**
+ * A plugin for `3d-tiles-renderer` that computes creased vertex normals for the
+ * geometry of each loaded tile: smooth normals everywhere except where faces meet
+ * at an angle greater than the crease angle. Useful for photogrammetry tile sets
+ * like Google Photorealistic 3D Tiles which come without vertex normals.
+ *
+ * The normals are computed in a Web Worker so tile processing doesn't block the
+ * main thread. Tiles are displayed once their normals are ready.
+ *
+ * ```js
+ * tiles.registerPlugin( new TileCreasedNormalsPlugin( { creaseAngle: Math.PI / 6 } ) );
+ * ```
+ *
+ * @three_import import { TileCreasedNormalsPlugin } from 'three/addons/misc/TileCreasedNormalsPlugin.js';
+ */
+export class TileCreasedNormalsPlugin {
+    /**
+     * Constructs a new plugin.
+     *
+     * @param {Object} [options] - The configuration options.
+     * @param {number} [options.creaseAngle=Math.PI/3] - The crease angle in radians.
+     */
+    constructor({ creaseAngle }?: TileCreasedNormalsPluginOptions);
+    /**
+     * The crease angle in radians.
+     *
+     * @type {number}
+     */
+    creaseAngle: number;
+    /**
+     * Called by the tiles renderer for each loaded tile model. The tile is
+     * displayed once the returned promise resolves.
+     *
+     * @param {Object3D} scene - The tile model.
+     * @return {Promise} A promise that resolves when all geometries have creased normals.
+     */
+    processTileModel(scene: Object3D): Promise<void>;
+    /**
+     * Called by the tiles renderer when the plugin is unregistered or the
+     * tiles renderer is disposed.
+     */
+    dispose(): void;
+}

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

@@ -72,5 +72,5 @@ export class MarchingCubes extends Mesh {
     generateBufferGeometry(): BufferGeometry;
 }
 
-export const edgeTable: Int32Array[];
-export const triTable: Int32Array[];
+export const edgeTable: Int32Array;
+export const triTable: Int32Array;