@types/three 0.184.0 → 0.185.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: Thu, 16 Apr 2026 19:29:33 GMT
+ * Last updated: Thu, 25 Jun 2026 18:41:21 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), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/Addons.d.ts

@@ -46,6 +46,7 @@ export * from "./exporters/USDZExporter.js";
 export * from "./geometries/BoxLineGeometry.js";
 export * from "./geometries/ConvexGeometry.js";
 export * from "./geometries/DecalGeometry.js";
+export * from "./geometries/LoftGeometry.js";
 export * from "./geometries/ParametricFunctions.js";
 export * from "./geometries/ParametricGeometry.js";
 export * from "./geometries/RoundedBoxGeometry.js";
@@ -284,6 +285,7 @@ export * from "./webxr/OculusHandModel.js";
 export * from "./webxr/OculusHandPointerModel.js";
 export * from "./webxr/Text2D.js";
 export * from "./webxr/VRButton.js";
+export * from "./webxr/WebGLXRFallback.js";
 export * from "./webxr/XRButton.js";
 export * from "./webxr/XRControllerModelFactory.js";
 export * from "./webxr/XREstimatedLight.js";

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

@@ -14,6 +14,15 @@ declare class FirstPersonControls extends Controls<{}> {
      */
     lookSpeed: number;
 
+    /**
+     * How quickly the movement and look velocity catches up to the input. Lower
+     * values feel heavier (more inertia), `1` disables damping.
+     *
+     * @type {number}
+     * @default 0.1
+     */
+    dampingFactor: number;
+
     /**
      * Whether or not it's possible to vertically look around. Default is `true`.
      */

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

@@ -20,7 +20,7 @@ export interface OrbitControlsEventMap {
 /**
  * Orbit controls allow the camera to orbit around a target.
  */
-declare class OrbitControls extends Controls<OrbitControlsEventMap> {
+declare class OrbitControls<TCamera extends Camera = Camera> extends Controls<OrbitControlsEventMap, TCamera> {
     /**
      * The focus point of the controls, the {@link .object} orbits around this. It can be updated manually at any point
      * to change the focus of the controls.
@@ -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 | SVGElement | null);
+    constructor(object: TCamera, domElement?: HTMLElement | SVGElement | null);
 
     set cursorStyle(type: "auto" | "grab");
     get cursorStyle(): "auto" | "grab";

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

@@ -1,4 +1,4 @@
-import { Camera, ColorRepresentation, Controls, Mesh, Object3D, Quaternion, Raycaster, Vector3 } from "three";
+import { Camera, ColorRepresentation, Controls, Mesh, Object3D, Quaternion, Raycaster, Vector3, Vector4 } from "three";
 
 export type TransformControlsMode = "translate" | "rotate" | "scale";
 
@@ -41,6 +41,8 @@ export interface TransformControlsEventMap {
     "showXY-changed": { value: unknown };
     "showYZ-changed": { value: unknown };
     "showXZ-changed": { value: unknown };
+    "showXYZE-changed": { value: unknown };
+    "showE-changed": { value: unknown };
     "minX-changed": { value: unknown };
     "maxX-changed": { value: unknown };
     "minY-changed": { value: unknown };
@@ -111,6 +113,17 @@ declare class TransformControls extends Controls<TransformControlsEventMap> {
      */
     size: number;
 
+    /**
+     * The viewport rectangle, in logical (CSS) pixels with the origin at the lower-left
+     * of the canvas. Set this when the renderer uses a sub-canvas viewport so pointer
+     * coordinates map to the correct region. If `null`, the full canvas is used.
+     *
+     * @name TransformControls#viewport
+     * @type {?Vector4}
+     * @default null
+     */
+    viewport: Vector4 | null;
+
     /**
      * Whether or not dragging is currently performed. Read-only property.
      */
@@ -152,6 +165,24 @@ declare class TransformControls extends Controls<TransformControlsEventMap> {
      */
     showXZ: boolean;
 
+    /**
+     * Whether the xyze rotation helper should be visible or not.
+     *
+     * @name TransformControls#showXYZE
+     * @type {boolean}
+     * @default true
+     */
+    showXYZE: boolean;
+
+    /**
+     * Whether the e rotation helper should be visible or not.
+     *
+     * @name TransformControls#showE
+     * @type {boolean}
+     * @default true
+     */
+    showE: boolean;
+
     /**
      * The minimum allowed X position during translation. Default is `-Infinity`.
      */

three/examples/jsm/csm/CSMFrustum.d.ts

@@ -1,25 +1,85 @@
 import { Matrix4, Vector3 } from "three";
 
-export interface CSMFrustumVerticies {
+export interface CSMFrustumVertices {
     near: Vector3[];
     far: Vector3[];
 }
 
 export interface CSMFrustumParameters {
-    webGL?: boolean;
-    projectionMatrix?: Matrix4;
-    maxFar?: number;
+    /**
+     * - Whether this CSM frustum is used with WebGL or WebGPU.
+     */
+    webGL?: boolean | undefined;
+    /**
+     * - Whether reversed depth buffer is enabled.
+     */
+    reversedDepth?: boolean | undefined;
+    /**
+     * - A projection matrix usually of the scene's camera.
+     */
+    projectionMatrix?: Matrix4 | undefined;
+    /**
+     * - The maximum far value.
+     */
+    maxFar?: number | undefined;
 }
 
-declare class CSMFrustum {
-    zNear: number;
-    vertices: CSMFrustumVerticies;
-
+/**
+ * Represents the frustum of a CSM instance.
+ *
+ * @three_import import { CSMFrustum } from 'three/addons/csm/CSMFrustum.js';
+ */
+export class CSMFrustum {
+    /**
+     * Constructs a new CSM frustum.
+     *
+     * @param {CSMFrustum~Data} [data] - The CSM data.
+     */
     constructor(data?: CSMFrustumParameters);
-
-    setFromProjectionMatrix(projectionMatrix: Matrix4, maxFar: number): CSMFrustumVerticies;
-    split(breaks: number[], target: CSMFrustum[]): void;
+    /**
+     * The zNear value. This value depends on whether the CSM
+     * is used with WebGL or WebGPU. Both API use different
+     * conventions for their projection matrices.
+     *
+     * @type {number}
+     */
+    zNear: number;
+    /**
+     * The zFar value.
+     *
+     * @type {number}
+     */
+    zFar: number;
+    /**
+     * An object representing the vertices of the near and
+     * far plane in view space.
+     *
+     * @type {Object}
+     */
+    vertices: CSMFrustumVertices;
+    /**
+     * Setups this CSM frustum from the given projection matrix and max far value.
+     *
+     * @param {Matrix4} projectionMatrix - The projection matrix, usually of the scene's camera.
+     * @param {number} maxFar - The maximum far value.
+     * @returns {Object} An object representing the vertices of the near and far plane in view space.
+     */
+    setFromProjectionMatrix(projectionMatrix: Matrix4, maxFar: number): CSMFrustumVertices;
+    /**
+     * Splits the CSM frustum by the given array. The new CSM frustum are pushed into the given
+     * target array.
+     *
+     * @param {Array<number>} breaks - An array of numbers in the range `[0,1]` the defines how the
+     * CSM frustum should be split up.
+     * @param {Array<CSMFrustum>} target - The target array that holds the new CSM frustums.
+     */
+    split(breaks: Array<number>, target: Array<CSMFrustum>): void;
+    /**
+     * Transforms the given target CSM frustum into the different coordinate system defined by the
+     * given camera matrix.
+     *
+     * @param {Matrix4} cameraMatrix - The matrix that defines the new coordinate system.
+     * @param {CSMFrustum} target - The CSM to convert.
+     */
     toSpace(cameraMatrix: Matrix4, target: CSMFrustum): void;
 }
-
-export { CSMFrustum };

three/examples/jsm/exporters/DRACOExporter.d.ts

@@ -13,5 +13,5 @@ export interface DRACOExporterOptions {
 export class DRACOExporter {
     constructor();
 
-    parse(object: Mesh | Points, options?: DRACOExporterOptions): Int8Array<ArrayBuffer>;
+    parseAsync(object: Mesh | Points, options?: DRACOExporterOptions): Promise<Int8Array<ArrayBuffer>>;
 }

three/examples/jsm/exporters/GLTFExporter.d.ts

@@ -34,7 +34,7 @@ export interface GLTFExporterOptions {
     /**
      * List of animations to be included in the export.
      */
-    animations?: AnimationClip[];
+    animations?: AnimationClip[] | AnimationClip[][];
 
     /**
      * Generate indices for non-index geometry and export with them. Default is false.
@@ -88,7 +88,7 @@ declare class GLTFExporter {
     parse(
         input: Object3D | Object3D[],
         onDone: (gltf: ArrayBuffer | { [key: string]: unknown }) => void,
-        onError: (error: ErrorEvent) => void,
+        onError: ((error: ErrorEvent) => void) | null,
         options?: GLTFExporterOptions,
     ): void;
 

three/examples/jsm/exporters/PLYExporter.d.ts

@@ -1,8 +1,9 @@
 import { Object3D } from "three";
 
 export interface PLYExporterOptionsBase {
-    excludeAttributes?: string[];
-    littleEndian?: boolean;
+    excludeAttributes?: string[] | undefined;
+    littleEndian?: boolean | undefined;
+    customPropertyMapping?: Record<string, string[]>;
 }
 
 export interface PLYExporterOptionsBinary extends PLYExporterOptionsBase {
@@ -10,11 +11,11 @@ export interface PLYExporterOptionsBinary extends PLYExporterOptionsBase {
 }
 
 export interface PLYExporterOptionsString extends PLYExporterOptionsBase {
-    binary?: false;
+    binary?: false | undefined;
 }
 
 export interface PLYExporterOptions extends PLYExporterOptionsBase {
-    binary?: boolean;
+    binary?: boolean | undefined;
 }
 
 export class PLYExporter {

three/examples/jsm/exporters/USDZExporter.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from "three";
+import { AnimationClip, Object3D } from "three";
 import * as WebGLTextureUtils from "../utils/WebGLTextureUtils.js";
 import * as WebGPUTextureUtils from "../utils/WebGPUTextureUtils.js";
 
@@ -8,6 +8,8 @@ export interface USDZExporterOptions {
     onlyVisible?: boolean | undefined;
     quickLookCompatible?: boolean | undefined;
     maxTextureSize?: number | undefined;
+    animations?: AnimationClip[] | undefined;
+    animationFrameRate?: number | undefined;
 }
 
 export class USDZExporter {
@@ -15,6 +17,8 @@ export class USDZExporter {
 
     constructor();
 
+    setTextureUtils(textureUtils: typeof WebGLTextureUtils | typeof WebGPUTextureUtils | null): void;
+
     parse(
         scene: Object3D,
         onDone: (result: Uint8Array<ArrayBuffer>) => void,

three/examples/jsm/generators/CityGenerator.d.ts

@@ -0,0 +1,75 @@
+import { Group, Material, MeshStandardNodeMaterial } from "three/webgpu";
+import { SidewalkGenerator } from "./city/SidewalkGenerator.js";
+import { SkyscraperGenerator } from "./city/SkyscraperGenerator.js";
+
+export interface CityGeneratorParameters {
+    seed: number;
+    street: number;
+    lot: number;
+    lotsX: number;
+    lotsZ: number;
+    blocksX: number;
+    blocksZ: number;
+    curbHeight: number;
+    curbRadius: number;
+}
+
+export interface CityGeneratorLayout {
+    street: number;
+    lot: number;
+    lotsX: number;
+    lotsZ: number;
+    blocksX: number;
+    blocksZ: number;
+    blockW: number;
+    blockD: number;
+    cityW: number;
+    cityD: number;
+}
+
+export interface CityGeneratorMaterials {
+    building?: Material | undefined;
+}
+
+/**
+ * Lays out a grid of city blocks and fills each lot with a {@link SkyscraperGenerator}
+ * tower of its own seed, height and footprint, optionally on raised sidewalk
+ * slabs (curbs). Returns a `THREE.Group` ready to add to a scene.
+ *
+ * Pass a building material to dress the towers; the sidewalks dress themselves
+ * via {@link SidewalkGenerator}. The layout is exposed as
+ * {@link CityGenerator#layout} so the surrounding scene (road markings, etc.)
+ * can align to the same grid.
+ *
+ * ```js
+ * const city = new CityGenerator( { seed: 1 } );
+ * scene.add( city.build( materials ) );
+ * ```
+ */
+export class CityGenerator {
+    constructor(parameters?: Partial<CityGeneratorParameters>);
+
+    parameters: CityGeneratorParameters;
+    layout: CityGeneratorLayout;
+
+    generators: SkyscraperGenerator[];
+    sidewalk: SidewalkGenerator;
+    group: Group | null;
+
+    build(materials?: CityGeneratorMaterials): Group;
+    dispose(): void;
+
+    static defaults: CityGeneratorParameters;
+}
+
+/**
+ * The shared material every tower in a {@link CityGenerator} is dressed with: one flat
+ * masonry colour per lot, picked from a palette by hashing the lot's grid cell.
+ */
+export function createBuildingMaterial(layout: CityGeneratorLayout, seed?: number): MeshStandardNodeMaterial;
+
+/**
+ * The road surface: wet asphalt with lane lines and crosswalks aligned to a
+ * {@link CityGenerator} layout. Apply it to a ground plane sized to the city.
+ */
+export function createRoadMaterial(layout: CityGeneratorLayout): MeshStandardNodeMaterial;

three/examples/jsm/generators/ForestGenerator.d.ts

@@ -0,0 +1,79 @@
+import { Group, InstancedMesh, MeshStandardNodeMaterial, Node, UniformNode, Vector3 } from "three/webgpu";
+import { TerrainGenerator } from "./TerrainGenerator.js";
+
+export interface ForestGeneratorParameters {
+    seed: number;
+    count: number;
+    detail: number;
+    radius: number;
+    height: number;
+    distortion: number;
+    sink: number;
+    altitudeMin: number;
+    altitudeMax: number;
+    minSlope: number;
+    densityFrequency: number;
+    minScale: number;
+    maxScale: number;
+    from: number;
+    to: number;
+    castShadow: boolean;
+}
+
+/**
+ * Carpets a {@link TerrainGenerator} ( or anything exposing `sampleHeight`,
+ * `sampleSlope`, `minY`, `maxY` and `parameters.size` ) with a forest of hundreds
+ * of thousands of trees in a single draw call.
+ *
+ * Each tree is the cheapest thing that still reads as a tree: a ~20-face icosphere
+ * squashed into a tapered teardrop and lumped with a little noise, carrying a baked
+ * dark-base / bright-top gradient. Tens of triangles each, so a single
+ * {@link THREE.InstancedMesh} of half a million of them costs one draw call. Trees
+ * are placed by rejection sampling against ecological rules — a min/max altitude
+ * band ( above the mist floor, below the snowline ), a slope limit ( none on
+ * cliffs ) and a low-frequency density mask that opens clearings — then jittered in
+ * yaw, lean and ( squared-biased ) scale so the stand never reads as copies.
+ *
+ * ```js
+ * const forest = new ForestGenerator( { count: 500000 } );
+ * scene.add( forest.build( terrain ) );
+ * ```
+ */
+export class ForestGenerator {
+    constructor(parameters?: Partial<ForestGeneratorParameters>);
+
+    parameters: ForestGeneratorParameters;
+
+    from: UniformNode<"float", number>;
+    to: UniformNode<"float", number>;
+
+    material: MeshStandardNodeMaterial;
+    mesh: InstancedMesh | null;
+    group: Group | null;
+
+    build(terrain: TerrainGenerator): Group;
+    setCameraPosition(position: Vector3): void;
+    dispose(): void;
+
+    static defaults: ForestGeneratorParameters;
+}
+
+/**
+ * The single material shared by every tree in a {@link ForestGenerator}. A plain
+ * MeshStandardNodeMaterial lit by the scene — only the surface is authored: deep
+ * shadowed green in the recesses rising to a bright, yellow-green sunlit crown,
+ * mottled into needle clumps by 3D noise, with a matching bump so the clumps catch
+ * the light. Half a million instanced blobs makes this mesh vertex-bound, so the
+ * regional colour drift is baked to a per-instance attribute ( no shader noise for it ),
+ * and the costly clump noise + bump are **gated by distance** — full detail on the near
+ * trees ( where it reads ), skipped on the far canopy ( where it is sub-pixel ).
+ *
+ * @param {Node} from - distance within which every tree is drawn.
+ * @param {Node} to - distance past which no tree is drawn.
+ * @return {MeshStandardNodeMaterial}
+ */
+export function createForestMaterial(
+    from: Node<"float">,
+    to: Node<"float">,
+    camPos: Node<"vec3">,
+): MeshStandardNodeMaterial;

three/examples/jsm/generators/TerrainGenerator.d.ts

@@ -0,0 +1,67 @@
+import { BufferGeometry, Group, MeshStandardNodeMaterial, UniformNode } from "three/webgpu";
+
+export interface TerrainGeneratorParameters {
+    seed: number;
+    size: number;
+    segments: number;
+    heightScale: number;
+    frequency: number;
+    octaves: number;
+    lacunarity: number;
+    gain: number;
+    erosion: number;
+    warp: number;
+    valleyBias: number;
+    seaLevel: number;
+    talus: number;
+    talusPasses: number;
+}
+
+/**
+ * Bakes a procedural mountain range into a single {@link THREE.BufferGeometry} and
+ * returns a `THREE.Group` ready to add to a scene.
+ *
+ * The heightfield is a derivative-damped fractal sum ( Quilez's fake erosion ): each
+ * octave is suppressed where the running slope is already steep, concentrating detail
+ * into weathered ridgelines, and a low-frequency domain warp makes those ridges
+ * meander. A few passes of thermal ( talus ) erosion then relax any slope past the
+ * angle of repose, settling the fractal's needle-spikes into real crests.
+ *
+ * The grid is triangulated with alternating quad diagonals ( a diamond pattern ), so a
+ * coarse mesh holds its silhouette without a one-way grain. The surface shades itself
+ * from altitude and slope in TSL — grass, forest, rock, scree and snow, with detail
+ * normals and aerial perspective — so no material or textures are needed.
+ *
+ * The baked height grid is exposed through {@link TerrainGenerator#sampleHeight} so a
+ * scattered forest ( or anything else ) can sit exactly on the surface.
+ *
+ * ```js
+ * const terrain = new TerrainGenerator( { seed: 1 } );
+ * scene.add( terrain.build() );
+ * ```
+ */
+export class TerrainGenerator {
+    constructor(parameters?: Partial<TerrainGeneratorParameters>);
+
+    parameters: TerrainGeneratorParameters;
+
+    minHeight: UniformNode<"float", number>;
+    maxHeight: UniformNode<"float", number>;
+
+    material: MeshStandardNodeMaterial;
+    geometry: BufferGeometry | null;
+    group: Group | null;
+
+    heights?: Float32Array;
+    gridSize?: number;
+    minY?: number;
+    maxY?: number;
+
+    build(): Group;
+
+    sampleHeight(x: number, z: number): number;
+    sampleSlope(x: number, z: number): number;
+    dispose(): void;
+
+    static defaults: TerrainGeneratorParameters;
+}

three/examples/jsm/generators/TreeGenerator.d.ts

@@ -0,0 +1,97 @@
+import { Color, Material, Mesh, MeshStandardNodeMaterial, Node } from "three/webgpu";
+
+export interface TreeGeneratorParameters {
+    seed: number;
+    levels: number;
+    children: number[];
+    branchAngle: number[];
+    angleVariance: number;
+    lengthRatio: number;
+    trunkLength: number;
+    trunkRadius: number;
+    taper: number;
+    taperCurve: number;
+    rootFlare: number;
+    flareFrac: number;
+    radiusExponent: number;
+    minRadius: number;
+    minLength: number;
+    droop: number;
+    upPull: number;
+    gnarl: number[];
+    radialSegments: number;
+    sectionLength: number;
+    childStart: number;
+    trunkClear: number;
+}
+
+/**
+ * Grows a procedural tree skeleton — trunk, branches and twigs, each swept as a tapered
+ * tube — and bakes it into one non-indexed {@link BufferGeometry} (position and normal
+ * only), ready to instance into a forest. It produces *branches only*; add foliage as a
+ * separate layer.
+ *
+ * The branching is deterministic for a given `seed`: a recursive sweep lays down gently
+ * curved tubes with a parallel-transport frame (so they never twist), forking by the
+ * pipe model (each child much thinner than its parent), spreading children along the
+ * upper part of each branch with a golden-angle roll, and pulling them back up toward
+ * the light. A flared root, non-linear taper and gravity droop fill in the character.
+ *
+ * Parameters are set with a fluent builder: a `set<Param>()` exists for every default
+ * ( `setSeed`, `setLevels`, `setChildren`, … ), each returning `this` for chaining.
+ *
+ * Each `build()` returns a fresh, independent mesh that the caller owns, so one
+ * generator can be re-parametrized and built repeatedly to grow a varied stand:
+ *
+ * ```js
+ * const generator = new TreeGenerator( material );
+ * const oak = generator.setSeed( 1 ).setLevels( 4 ).build();
+ * const pine = generator.setSeed( 2 ).setLevels( 5 ).build();
+ * ```
+ */
+export class TreeGenerator {
+    constructor(material?: Material | null);
+
+    material: Material | null;
+    parameters: Partial<TreeGeneratorParameters>;
+
+    build(): Mesh;
+
+    static defaults: TreeGeneratorParameters;
+
+    setSeed: (seed: number) => this;
+    setLevels: (levels: number) => this;
+    setChildren: (children: number[]) => this;
+    setBranchAngle: (branchAngle: number[]) => this;
+    setAngleVariance: (angleVariance: number) => this;
+    setLengthRatio: (lengthRatio: number) => this;
+    setTrunkLength: (trunkLength: number) => this;
+    setTrunkRadius: (trunkRadius: number) => this;
+    setTaper: (taper: number) => this;
+    setTaperCurve: (taperCurve: number) => this;
+    setRootFlare: (rootFlare: number) => this;
+    setFlareFrac: (flareFrac: number) => this;
+    setRadiusExponent: (radiusExponent: number) => this;
+    setMinRadius: (minRadius: number) => this;
+    setMinLength: (minLength: number) => this;
+    setDroop: (droop: number) => this;
+    setUpPull: (upPull: number) => this;
+    setGnarl: (gnarl: number[]) => this;
+    setRadialSegments: (radialSegments: number) => this;
+    setSectionLength: (sectionLength: number) => this;
+    setChildStart: (childStart: number) => this;
+    setTrunkClear: (trunkClear: number) => this;
+}
+
+export interface TreeMaterialParameters {
+    barkColor?: Color | number | Node<"color"> | undefined;
+}
+
+/**
+ * A simple bark material for a {@link TreeGenerator} mesh: a low-saturation brown with a
+ * faint, vertically-stretched grain, so trunks read near-black against bright fog.
+ *
+ * @param {Object} [parameters] - `barkColor` ( a hex, THREE.Color or TSL node ).
+ * @return {MeshStandardNodeMaterial}
+ */
+export function createTreeMaterial(parameters?: TreeMaterialParameters): MeshStandardNodeMaterial;

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

@@ -0,0 +1,40 @@
+import { Group, Matrix4, MeshStandardNodeMaterial } from "three/webgpu";
+
+export interface SidewalkGeneratorParameters {
+    width: number;
+    depth: number;
+    height: number;
+    radius: number;
+    curbWidth: number;
+    curbLip: number;
+}
+
+/**
+ * Generates the raised sidewalk for a city's blocks: per block, a rounded-corner concrete
+ * slab rimmed by a distinct granite kerbstone that stands proud of the walking surface and
+ * drops to the road. Instanced across a list of placements and dressed with its own
+ * procedural material ( poured concrete flags, scored expansion joints, granite curb ).
+ * Returns a `THREE.Group` of two instanced meshes — the walking slab and the curb.
+ *
+ * Unlike the building generator, this one owns its materials: the slab and curb
+ * geometry and the TSL that shades them live together here.
+ *
+ * ```js
+ * const sidewalk = new SidewalkGenerator( { width: 90, depth: 60, height: 0.5 } );
+ * scene.add( sidewalk.build( placements ) ); // placements: Matrix4[]
+ * ```
+ */
+export class SidewalkGenerator {
+    constructor(parameters?: Partial<SidewalkGeneratorParameters>);
+
+    parameters: SidewalkGeneratorParameters;
+
+    material: MeshStandardNodeMaterial | null;
+    curbMaterial: MeshStandardNodeMaterial | null;
+    mesh: Group | null;
+
+    build(placements: Matrix4[]): Group;
+    dispose(): void;
+
+    static defaults: SidewalkGeneratorParameters;
+}