@needle-tools/three 0.169.12 → 0.169.13

package/types/examples/jsm/libs/meshopt_decoder.module.d.ts

@@ -0,0 +1 @@
+export * from "meshoptimizer/meshopt_decoder.module.js";

package/types/examples/jsm/libs/stats.module.d.ts

@@ -0,0 +1,3 @@
+import Stats = require("stats.js");
+
+export default Stats;

package/types/examples/jsm/libs/tween.module.d.ts

@@ -0,0 +1,2 @@
+export * from "@tweenjs/tween.js";
+export { default as default } from "@tweenjs/tween.js";

package/types/examples/jsm/lights/LightProbeGenerator.d.ts

@@ -0,0 +1,10 @@
+import { CubeTexture, LightProbe, WebGLCubeRenderTarget, WebGLRenderer } from "three";
+import { WebGPURenderer } from "three/webgpu";
+
+export namespace LightProbeGenerator {
+    function fromCubeTexture(cubeTexture: CubeTexture): LightProbe;
+    function fromCubeRenderTarget(
+        renderer: WebGLRenderer | WebGPURenderer,
+        cubeRenderTarget: WebGLCubeRenderTarget,
+    ): Promise<LightProbe>;
+}

package/types/examples/jsm/lights/RectAreaLightTexturesLib.d.ts

@@ -0,0 +1,7 @@
+import { RectAreaLightTexturesLib as RectAreaLightTexturesLibInterface } from "three/webgpu";
+
+declare class RectAreaLightTexturesLib {
+    static init(): RectAreaLightTexturesLibInterface;
+}
+
+export { RectAreaLightTexturesLib };

package/types/examples/jsm/lights/RectAreaLightUniformsLib.d.ts

@@ -0,0 +1,5 @@
+declare class RectAreaLightUniformsLib {
+    static init(): void;
+}
+
+export { RectAreaLightUniformsLib };

package/types/examples/jsm/lines/Line2.d.ts

@@ -0,0 +1,25 @@
+import { LineGeometry } from "./LineGeometry.js";
+import { LineMaterial } from "./LineMaterial.js";
+import { LineSegments2 } from "./LineSegments2.js";
+
+/**
+ * A polyline drawn between vertices.
+ *
+ * This adds functionality beyond {@link Line}, like arbitrary line width and changing width to be in world units. It
+ * extends {@link LineSegments2}, simplifying constructing segments from a chain of points.
+ */
+export class Line2 extends LineSegments2 {
+    geometry: LineGeometry;
+    material: LineMaterial;
+
+    /**
+     * Read-only flag to check if a given object is of type Line2.
+     */
+    readonly isLine2: true;
+
+    /**
+     * @param geometry (optional) Pair(s) of vertices representing each line segment
+     * @param material (optional) Material for the line. Default is a {@link LineMaterial} with random color.
+     */
+    constructor(geometry?: LineGeometry, material?: LineMaterial);
+}

package/types/examples/jsm/lines/LineGeometry.d.ts

@@ -0,0 +1,27 @@
+import { Line } from "three";
+
+import { LineSegmentsGeometry } from "./LineSegmentsGeometry.js";
+
+/**
+ * A chain of vertices, forming a polyline.
+ *
+ * This is used in {@link Line2} to describe the shape.
+ */
+export class LineGeometry extends LineSegmentsGeometry {
+    /**
+     * Read-only flag to check if a given object is of type LineGeometry.
+     */
+    readonly isLineGeometry: true;
+
+    /**
+     * Creates a new geometry.
+     * Call [setPositions]{@link LineGeometry.setPositions} to add segments.
+     */
+    constructor();
+
+    /**
+     * Copy the vertex positions of a {@link Line} object into this geometry.
+     * Assumes the source geometry is not using indices.
+     */
+    fromLine(line: Line): this;
+}

package/types/examples/jsm/lines/LineMaterial.d.ts

@@ -0,0 +1,82 @@
+import { Color, ColorRepresentation, ShaderMaterial, ShaderMaterialParameters, Vector2 } from "three";
+
+export interface LineMaterialParameters extends ShaderMaterialParameters {
+    alphaToCoverage?: boolean | undefined;
+    color?: ColorRepresentation | undefined;
+    dashed?: boolean | undefined;
+    dashScale?: number | undefined;
+    dashSize?: number | undefined;
+    dashOffset?: number | undefined;
+    gapSize?: number | undefined;
+    resolution?: Vector2 | undefined;
+    worldUnits?: boolean | undefined;
+}
+
+/**
+ * A material for drawing wireframe-style geometries.
+ * Unlike {@link LineBasicMaterial}, it supports arbitrary line widths and allows using world units instead of screen
+ * space units. This material is used with {@link LineSegments2} and {@link Line2}.
+ *
+ * Lines are always rendered with round caps and round joints.
+ */
+export class LineMaterial extends ShaderMaterial {
+    readonly isLineMaterial: true;
+
+    /**
+     * @param parameters (optional) an object with one or more properties defining the material's appearance. Any
+     * property of the material (including any property inherited from {@link ShaderMaterial}) can be passed in here.
+     *
+     * The exception is the property color, which can be passed in as a number or hexadecimal string and is `0xffffff`
+     * (white) by default. Color.set( color ) is called internally.
+     */
+    constructor(parameters?: LineMaterialParameters);
+
+    /**
+     * {@link Color} of the material, by default set to white (0xffffff).
+     */
+    get color(): Color;
+    set color(value: Color);
+
+    /**
+     * Whether the material's sizes (width, dash gaps) are in world units. Default is `false` (screen space units.)
+     */
+    get worldUnits(): boolean;
+    set worldUnits(value: boolean);
+
+    /**
+     * Whether the line is dashed, or solid. Default is `false`.
+     */
+    get dashed(): boolean;
+    set dashed(value: boolean);
+
+    /**
+     * The scale of the dashes and gaps. Default is `1`.
+     */
+    get dashScale(): number;
+    set dashScale(value: number);
+
+    /**
+     * The size of the dash. Default is `1`.
+     */
+    get dashSize(): number;
+    set dashSize(value: number);
+
+    /**
+     * Where in the dash cycle the dash starts. Default is `0`.
+     */
+    get dashOffset(): number;
+    set dashOffset(value: number);
+
+    /**
+     * The size of the gap. Default is `1`.
+     */
+    get gapSize(): number;
+    set gapSize(value: number);
+
+    /**
+     * The size of the viewport, in screen pixels. This must be kept updated to make screen-space rendering accurate.
+     * The {@link LineSegments2.onBeforeRender} callback performs the update for visible objects. Default is `[1, 1]`.
+     */
+    get resolution(): Vector2;
+    set resolution(value: Vector2);
+}

package/types/examples/jsm/lines/LineSegments2.d.ts

@@ -0,0 +1,37 @@
+import { Mesh, WebGLRenderer } from "three";
+
+import { LineMaterial } from "./LineMaterial.js";
+import { LineSegmentsGeometry } from "./LineSegmentsGeometry.js";
+
+/**
+ * A series of lines drawn between pairs of vertices.
+ *
+ * This adds functionality beyond {@link LineSegments}, like arbitrary line width and changing width to be in world
+ * units. The {@link Line2} extends this object, forming a polyline instead of individual segments.
+ */
+export class LineSegments2 extends Mesh {
+    geometry: LineSegmentsGeometry;
+    material: LineMaterial;
+
+    /**
+     * Read-only flag to check if a given object is of type LineSegments2.
+     */
+    readonly isLineSegments2: true;
+
+    /**
+     * @param geometry (optional) Pair(s) of vertices representing each line segment.
+     * @param material (optional) Material for the line. Default is a {@link LineMaterial} with random color.
+     */
+    constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
+
+    computeLineDistances(): this;
+
+    /**
+     * Called by the framework to update the material's resolution property, needed for screen-scaled widths.
+     *
+     * If your object is not visible to a camera (e.g. by [layers]{@link Object3D.layers} or
+     * [visible]{@link Object3D.visible}), you must call this manually whenever the viewport changes.
+     * @param renderer
+     */
+    onBeforeRender(renderer: WebGLRenderer): void;
+}

package/types/examples/jsm/lines/LineSegmentsGeometry.d.ts

@@ -0,0 +1,53 @@
+import { EdgesGeometry, InstancedBufferGeometry, LineSegments, Mesh, WireframeGeometry } from "three";
+
+/**
+ * A series of vertex pairs, forming line segments.
+ *
+ * This is used in {@link LineSegments2} to describe the shape.
+ */
+export class LineSegmentsGeometry extends InstancedBufferGeometry {
+    /**
+     * Read-only flag to check if a given object is of type LineSegmentsGeometry.
+     */
+    readonly isLineSegmentsGeometry: true;
+
+    /**
+     * Creates a new geometry. Call [setPositions]{@link LineSegmentsGeometry.setPositions} to add segments.
+     */
+    constructor();
+
+    /**
+     * Replace the vertex positions with a new set. The array can be an `Array` or `Float32Array`. The length must be a
+     * multiple of six.
+     * @param array
+     */
+    setPositions(array: number[] | Float32Array): this;
+
+    /**
+     * Replace the per-vertex colors. Every sixtuple describes a segment: `[r1, g1, b1, r2, g2, b2]`. The array can be
+     * an `Array` or `Float32Array`.
+     * @param array
+     */
+    setColors(array: number[] | Float32Array): this;
+
+    /**
+     * Copy the vertex positions of a wireframe geometry into this geometry.
+     */
+    fromWireframeGeometry(geometry: WireframeGeometry): this;
+
+    /**
+     * Copy the vertex positions of an edge geometry into this geometry.
+     */
+    fromEdgesGeometry(geometry: EdgesGeometry): this;
+
+    /**
+     * Copy the vertex positions of a mesh object into this geometry.
+     */
+    fromMesh(mesh: Mesh): this;
+
+    /**
+     * Copy the vertex positions of a {@link LineSegments} object into this geometry. Assumes the source geometry is not
+     * using indices.
+     */
+    fromLineSegments(lineSegments: LineSegments): this;
+}

package/types/examples/jsm/lines/Wireframe.d.ts

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

package/types/examples/jsm/lines/WireframeGeometry2.d.ts

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

package/types/examples/jsm/lines/webgpu/Line2.d.ts

@@ -0,0 +1,14 @@
+import { Line2NodeMaterial } from "three/webgpu";
+import { LineGeometry } from "../LineGeometry.js";
+import { LineSegments2 } from "./LineSegments2.js";
+
+declare class Line2 extends LineSegments2 {
+    geometry: LineGeometry;
+    material: Line2NodeMaterial;
+
+    readonly isLine2: true;
+
+    constructor(geometry?: LineGeometry, material?: Line2NodeMaterial);
+}
+
+export { Line2 };

package/types/examples/jsm/lines/webgpu/LineSegments2.d.ts

@@ -0,0 +1,15 @@
+import { Line2NodeMaterial, Mesh } from "three/webgpu";
+import { LineSegmentsGeometry } from "../LineSegmentsGeometry.js";
+
+declare class LineSegments2 extends Mesh {
+    geometry: LineSegmentsGeometry;
+    material: Line2NodeMaterial;
+
+    readonly isLineSegments2: true;
+
+    constructor(geometry?: LineSegmentsGeometry, material?: Line2NodeMaterial);
+
+    computeLineDistances(): this;
+}
+
+export { LineSegments2 };

package/types/examples/jsm/loaders/3DMLoader.d.ts

@@ -0,0 +1,10 @@
+import { Loader, LoadingManager, Object3D } from "three";
+
+export class Rhino3dmLoader extends Loader<Object3D> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBufferLike, onLoad: (object: Object3D) => void, onError?: (event: ErrorEvent) => void): void;
+    setLibraryPath(path: string): Rhino3dmLoader;
+    setWorkerLimit(workerLimit: number): Rhino3dmLoader;
+    dispose(): Rhino3dmLoader;
+}

package/types/examples/jsm/loaders/3MFLoader.d.ts

@@ -0,0 +1,9 @@
+import { Group, Loader, LoadingManager } from "three";
+
+export class ThreeMFLoader extends Loader<Group> {
+    constructor(manager?: LoadingManager);
+    availableExtensions: object[];
+
+    parse(data: ArrayBuffer): Group;
+    addExtension(extension: object): void;
+}

package/types/examples/jsm/loaders/AMFLoader.d.ts

@@ -0,0 +1,7 @@
+import { Group, Loader, LoadingManager } from "three";
+
+export class AMFLoader extends Loader<Group> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBuffer): Group;
+}

package/types/examples/jsm/loaders/BVHLoader.d.ts

@@ -0,0 +1,14 @@
+import { AnimationClip, Loader, LoadingManager, Skeleton } from "three";
+
+export interface BVH {
+    clip: AnimationClip;
+    skeleton: Skeleton;
+}
+
+export class BVHLoader extends Loader<BVH> {
+    constructor(manager?: LoadingManager);
+    animateBonePositions: boolean;
+    animateBoneRotations: boolean;
+
+    parse(text: string): BVH;
+}

package/types/examples/jsm/loaders/ColladaLoader.d.ts

@@ -0,0 +1,11 @@
+import { Loader, Scene } from "three";
+
+export interface Collada {
+    kinematics: object;
+    library: object;
+    scene: Scene;
+}
+
+export class ColladaLoader extends Loader<Collada> {
+    parse(text: string, path: string): Collada;
+}

package/types/examples/jsm/loaders/DDSLoader.d.ts

@@ -0,0 +1,22 @@
+import {
+    CompressedPixelFormat,
+    CompressedTextureLoader,
+    CompressedTextureMipmap,
+    LoadingManager,
+    PixelFormat,
+} from "three";
+
+export interface DDS {
+    mipmaps: CompressedTextureMipmap[];
+    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/types/examples/jsm/loaders/DRACOLoader.d.ts

@@ -0,0 +1,25 @@
+import { BufferGeometry, Loader, LoadingManager } from "three";
+
+export class DRACOLoader extends Loader<BufferGeometry> {
+    constructor(manager?: LoadingManager);
+
+    setDecoderPath(path: string): DRACOLoader;
+    setDecoderConfig(config: object): DRACOLoader;
+    setWorkerLimit(workerLimit: number): DRACOLoader;
+
+    load(
+        url: string,
+        onLoad?: (data: BufferGeometry) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+
+    parse(
+        buffer: ArrayBuffer,
+        onLoad?: (geometry: BufferGeometry) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+
+    preload(): DRACOLoader;
+    dispose(): DRACOLoader;
+}

package/types/examples/jsm/loaders/EXRLoader.d.ts

@@ -0,0 +1,19 @@
+import { ColorSpace, DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
+
+export interface EXR {
+    header: object;
+    width: number;
+    height: number;
+    data: Float32Array | Uint16Array;
+    format: PixelFormat;
+    colorSpace: ColorSpace;
+    type: TextureDataType;
+}
+
+export class EXRLoader extends DataTextureLoader {
+    constructor(manager?: LoadingManager);
+    type: TextureDataType;
+
+    parse(buffer: ArrayBuffer): EXR;
+    setDataType(type: TextureDataType): this;
+}

package/types/examples/jsm/loaders/FBXLoader.d.ts

@@ -0,0 +1,7 @@
+import { Group, Loader, LoadingManager } from "three";
+
+export class FBXLoader extends Loader<Group> {
+    constructor(manager?: LoadingManager);
+
+    parse(FBXBuffer: ArrayBuffer | string, path: string): Group;
+}

package/types/examples/jsm/loaders/FontLoader.d.ts

@@ -0,0 +1,41 @@
+import { Loader, LoadingManager, Shape } from "three";
+
+export interface FontData {
+    glyphs: Record<string, { ha: number; x_min: number; x_max: number; o?: string | undefined }>;
+    familyName: string;
+    ascender: number;
+    descender: number;
+    underlinePosition: number;
+    underlineThickness: number;
+    boundingBox: { yMin: number; xMin: number; yMax: number; xMax: number };
+    resolution: number;
+    original_font_information: Record<string, string>;
+}
+
+export class FontLoader extends Loader<Font> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: Font) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+
+    parse(json: FontData): Font;
+}
+
+export class Font {
+    readonly isFont: true;
+
+    /**
+     * @default 'Font'
+     */
+    type: string;
+
+    data: FontData;
+
+    constructor(data: FontData);
+
+    generateShapes(text: string, size?: number): Shape[];
+}

package/types/examples/jsm/loaders/GCodeLoader.d.ts

@@ -0,0 +1,8 @@
+import { Group, Loader, LoadingManager } from "three";
+
+export class GCodeLoader extends Loader<Group> {
+    constructor(manager?: LoadingManager);
+    splitLayer: boolean;
+
+    parse(data: string): Group;
+}

package/types/examples/jsm/loaders/GLTFLoader.d.ts

@@ -0,0 +1,153 @@
+import {
+    AnimationClip,
+    BufferAttribute,
+    BufferGeometry,
+    Camera,
+    ColorSpace,
+    FileLoader,
+    Group,
+    ImageBitmapLoader,
+    InterleavedBufferAttribute,
+    Loader,
+    LoadingManager,
+    Material,
+    Mesh,
+    MeshStandardMaterial,
+    Object3D,
+    Skeleton,
+    SkinnedMesh,
+    Texture,
+    TextureLoader,
+} from "three";
+
+import { MeshoptDecoder } from "../libs/meshopt_decoder.module.js";
+import { DRACOLoader } from "./DRACOLoader.js";
+import { KTX2Loader } from "./KTX2Loader.js";
+
+export interface GLTF {
+    animations: AnimationClip[];
+    scene: Group;
+    scenes: Group[];
+    cameras: Camera[];
+    asset: {
+        copyright?: string | undefined;
+        generator?: string | undefined;
+        version?: string | undefined;
+        minVersion?: string | undefined;
+        extensions?: any;
+        extras?: any;
+    };
+    parser: GLTFParser;
+    userData: Record<string, any>;
+}
+
+export class GLTFLoader extends Loader<GLTF> {
+    dracoLoader: DRACOLoader | null;
+    ktx2Loader: KTX2Loader | null;
+    meshoptDecoder: typeof MeshoptDecoder | null;
+
+    constructor(manager?: LoadingManager);
+
+    setDRACOLoader(dracoLoader: DRACOLoader): this;
+    setKTX2Loader(ktx2Loader: KTX2Loader | null): this;
+    setMeshoptDecoder(meshoptDecoder: typeof MeshoptDecoder | null): this;
+
+    register(callback: (parser: GLTFParser) => GLTFLoaderPlugin): this;
+    unregister(callback: (parser: GLTFParser) => GLTFLoaderPlugin): this;
+
+    parse(
+        data: ArrayBuffer | string,
+        path: string,
+        onLoad: (gltf: GLTF) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+
+    parseAsync(data: ArrayBuffer | string, path: string): Promise<GLTF>;
+}
+
+export type GLTFReferenceType = "materials" | "nodes" | "textures" | "meshes";
+
+export interface GLTFReference {
+    materials?: number;
+    nodes?: number;
+    textures?: number;
+    meshes?: number;
+}
+
+export class GLTFParser {
+    json: any;
+
+    options: {
+        path: string;
+        manager: LoadingManager;
+        ktx2Loader: KTX2Loader;
+        meshoptDecoder: /* MeshoptDecoder */ any;
+        crossOrigin: string;
+        requestHeader: { [header: string]: string };
+    };
+
+    fileLoader: FileLoader;
+    textureLoader: TextureLoader | ImageBitmapLoader;
+    plugins: { [name: string]: GLTFLoaderPlugin };
+    extensions: { [name: string]: any };
+    associations: Map<Object3D | Material | Texture, GLTFReference>;
+
+    setExtensions(extensions: { [name: string]: any }): void;
+    setPlugins(plugins: { [name: string]: GLTFLoaderPlugin }): void;
+
+    parse(onLoad: (gltf: GLTF) => void, onError?: (event: ErrorEvent) => void): void;
+
+    getDependency: (type: string, index: number) => Promise<any>;
+    getDependencies: (type: string) => Promise<any[]>;
+    loadBuffer: (bufferIndex: number) => Promise<ArrayBuffer>;
+    loadBufferView: (bufferViewIndex: number) => Promise<ArrayBuffer>;
+    loadAccessor: (accessorIndex: number) => Promise<BufferAttribute | InterleavedBufferAttribute>;
+    loadTexture: (textureIndex: number) => Promise<Texture>;
+    loadTextureImage: (textureIndex: number, sourceIndex: number, loader: Loader) => Promise<Texture>;
+    loadImageSource: (sourceIndex: number, loader: Loader) => Promise<Texture>;
+    assignTexture: (
+        materialParams: { [key: string]: any },
+        mapName: string,
+        mapDef: {
+            index: number;
+            texCoord?: number | undefined;
+            extensions?: any;
+        },
+        colorSpace?: ColorSpace | undefined,
+    ) => Promise<Texture | null>;
+    assignFinalMaterial: (object: Mesh) => void;
+    getMaterialType: () => typeof MeshStandardMaterial;
+    loadMaterial: (materialIndex: number) => Promise<Material>;
+    createUniqueName: (originalName: string) => string;
+    createNodeMesh: (nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh>;
+    loadGeometries: (
+        /**
+         * GLTF.Primitive[]
+         * See: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/mesh.primitive.schema.json
+         */
+        primitives: Array<{ [key: string]: any }>,
+    ) => Promise<BufferGeometry[]>;
+    loadMesh: (meshIndex: number) => Promise<Group | Mesh | SkinnedMesh>;
+    loadCamera: (cameraIndex: number) => Promise<Camera>;
+    loadSkin: (skinIndex: number) => Promise<Skeleton>;
+    loadAnimation: (animationIndex: number) => Promise<AnimationClip>;
+    loadNode: (nodeIndex: number) => Promise<Object3D>;
+    loadScene: () => Promise<Group>;
+}
+
+export interface GLTFLoaderPlugin {
+    readonly name: string;
+    beforeRoot?: (() => Promise<void> | null) | undefined;
+    afterRoot?: ((result: GLTF) => Promise<void> | null) | undefined;
+    loadNode?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
+    loadMesh?: ((meshIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
+    loadBufferView?: ((bufferViewIndex: number) => Promise<ArrayBuffer> | null) | undefined;
+    loadMaterial?: ((materialIndex: number) => Promise<Material> | null) | undefined;
+    loadTexture?: ((textureIndex: number) => Promise<Texture> | null) | undefined;
+    getMaterialType?: ((materialIndex: number) => typeof Material | null) | undefined;
+    extendMaterialParams?:
+        | ((materialIndex: number, materialParams: { [key: string]: any }) => Promise<any> | null)
+        | undefined;
+    createNodeMesh?: ((nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
+    createNodeAttachment?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
+}