@types/three 0.160.0 → 0.161.0

three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -2,6 +2,7 @@ import {
     LineBasicMaterial,
     Material,
     MeshBasicMaterial,
+    MeshPhongMaterial,
     MeshPhysicalMaterial,
     MeshStandardMaterial,
     PointsMaterial,
@@ -10,23 +11,24 @@ import {
 } from '../../../../src/Three.js';
 import NodeBuilder from '../core/NodeBuilder.js';
 import Node from '../core/Node.js';
-import { LightingModelNode } from '../lighting/LightingContextNode.js';
 import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
 import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
 import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
 import PointsNodeMaterial from './PointsNodeMaterial.js';
 import SpriteNodeMaterial from './SpriteNodeMaterial.js';
+import LightsNode from '../lighting/LightsNode.js';
+import LightingModel from '../core/LightingModel.js';
+import MeshPhongNodeMaterial from './MeshPhongNodeMaterial.js';
 
 export default class NodeMaterial extends ShaderMaterial {
-    isNodeMaterial: true;
+    readonly isNodeMaterial: true;
 
-    type: string;
+    normals: boolean;
 
-    lights: true;
-    normals: true;
+    colorSpaced: boolean;
 
-    lightsNode: Node | null;
+    lightsNode: LightsNode | null;
     envNode: Node | null;
 
     colorNode: Node | null;
@@ -38,20 +40,34 @@ export default class NodeMaterial extends ShaderMaterial {
 
     positionNode: Node | null;
 
+    depthNode: Node | null;
+    shadowNode: Node | null;
+
+    outputNode: Node | null;
+
+    fragmentNode: Node | null;
+    vertexNode: Node | null;
+
     constructor();
 
     build(builder: NodeBuilder): void;
-    customProgramCacheKey(): string;
-    generatePosition(builder: NodeBuilder): void;
-    generateDiffuseColor(builder: NodeBuilder): void;
-    generateLight(
-        builder: NodeBuilder,
-        lights: { diffuseColorNode: Node; lightingModelNode: LightingModelNode; lightsNode?: Node },
-    ): void;
-    generateOutput(builder: NodeBuilder, lights: { diffuseColorNode: Node; outgoingLightNode: Node }): void;
+    setup(builder: NodeBuilder): void;
+    setupDepth(builder: NodeBuilder): void;
+    setupPosition(builder: NodeBuilder): Node;
+    setupDiffuseColor(builder: NodeBuilder): void;
+    setupVariants(builder: NodeBuilder): void;
+    setupNormal(builder: NodeBuilder): void;
+    getEnvNode(builder: NodeBuilder): Node | null;
+    setupLights(builder: NodeBuilder): LightsNode;
+    setupLightingModel(builder: NodeBuilder): LightingModel;
+    setupLighting(builder: NodeBuilder): Node;
+    setupOutput(builder: NodeBuilder, outputNode: Node): Node;
+
+    setDefaultValues(material: Material): void;
 
     static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
     static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
     static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
     static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
     static fromMaterial(material: PointsMaterial): PointsNodeMaterial;

three/examples/jsm/nodes/materials/PointsNodeMaterial.d.ts

@@ -3,13 +3,7 @@ import { ShaderMaterialParameters } from '../../../../src/Three.js';
 import { Node } from '../Nodes.js';
 
 export default class PointsNodeMaterial extends NodeMaterial {
-    isPointsNodeMateria: true;
-    colorNode: Node | null;
-    opacityNode: Node | null;
-    alphaTestNode: Node | null;
-    lightNode: Node | null;
-    sizeNode: Node | null;
-    positionNode: Node | null;
+    readonly isPointsNodeMaterial: true;
+
     constructor(parameters?: ShaderMaterialParameters);
-    copy(source: PointsNodeMaterial): this;
 }

three/examples/jsm/nodes/materials/SpriteNodeMaterial.d.ts

@@ -6,18 +6,8 @@ import Node from '../core/Node.js';
 export default class SpriteNodeMaterial extends NodeMaterial {
     isSpriteNodeMaterial: true;
 
-    colorNode: Node | null;
-    opacityNode: Node | null;
-
-    alphaTestNode: Node | null;
-
-    lightNode: Node | null;
-
-    positionNode: Node | null;
     rotationNode: Node | null;
     scaleNode: Node | null;
 
     constructor(parameters?: ShaderMaterialParameters);
-    generatePosition(builder: NodeBuilder): void;
-    copy(source: SpriteNodeMaterial): this;
 }

three/examples/jsm/nodes/math/CondNode.d.ts

@@ -14,3 +14,9 @@ export function cond(
     ifNode: NodeRepresentation,
     elseNode: NodeRepresentation,
 ): ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        cond: typeof cond;
+    }
+}

three/examples/jsm/nodes/math/HashNode.d.ts

@@ -0,0 +1,16 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class HashNode extends Node {
+    seedNode: Node;
+
+    constructor(seedNode: Node);
+}
+
+export const hash: (seedNode: NodeRepresentation) => ShaderNodeObject<HashNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        hash: typeof hash;
+    }
+}

three/examples/jsm/nodes/math/MathNode.d.ts

@@ -124,8 +124,10 @@ export default class MathNode extends TempNode {
 
 export const EPSILON: ShaderNodeObject<Node>;
 export const INFINITY: ShaderNodeObject<Node>;
+export const PI: ShaderNodeObject<Node>;
+export const PI2: ShaderNodeObject<Node>;
 
-export type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
+type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
 export const radians: Unary;
 export const degrees: Unary;
@@ -158,7 +160,7 @@ export const trunc: Unary;
 export const fwidth: Unary;
 export const bitcast: Unary;
 
-export type Binary = (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
+type Binary = (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
 export const atan2: Binary;
 export const min: Binary;
@@ -176,15 +178,17 @@ export const pow3: Binary;
 export const pow4: Binary;
 export const transformDirection: Binary;
 
-export type Ternary = (
-    a: NodeRepresentation,
-    b: NodeRepresentation,
-    c: NodeRepresentation,
-) => ShaderNodeObject<MathNode>;
+type Ternary = (a: NodeRepresentation, b: NodeRepresentation, c: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
+export const cbrt: Unary;
+export const lengthSq: Unary;
 export const mix: Ternary;
-export const clamp: Ternary;
-export const saturate: Ternary;
+export const clamp: (
+    a: NodeRepresentation,
+    b?: NodeRepresentation,
+    c?: NodeRepresentation,
+) => ShaderNodeObject<MathNode>;
+export const saturate: Unary;
 export const refract: Ternary;
 export const smoothstep: Ternary;
 export const faceForward: Ternary;
@@ -215,6 +219,7 @@ declare module '../shadernode/ShaderNode.js' {
         abs: typeof abs;
         sign: typeof sign;
         length: typeof length;
+        lengthSq: typeof lengthSq;
         negate: typeof negate;
         oneMinus: typeof oneMinus;
         dFdx: typeof dFdx;
@@ -244,5 +249,6 @@ declare module '../shadernode/ShaderNode.js' {
         faceForward: typeof faceForward;
         difference: typeof difference;
         saturate: typeof saturate;
+        cbrt: typeof cbrt;
     }
 }

three/examples/jsm/nodes/math/MathUtils.d.ts

@@ -0,0 +1,16 @@
+import { Binary, Ternary } from './MathNode.js';
+
+// remapping functions
+export const parabola: Binary;
+export const gain: Binary;
+export const pcurve: Ternary;
+export const sinc: Binary;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        parabola: typeof parabola;
+        gain: typeof gain;
+        pcurve: typeof pcurve;
+        sinc: typeof sinc;
+    }
+}

three/examples/jsm/nodes/math/OperatorNode.d.ts

@@ -3,7 +3,6 @@ import Node from '../core/Node.js';
 import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type OperatorNodeOp =
-    | '='
     | '%'
     | '&'
     | '|'
@@ -31,7 +30,7 @@ export default class OperatorNode extends TempNode {
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
 
-export type Operator = (
+type Operator = (
     a: NodeRepresentation,
     b: NodeRepresentation,
     ...others: NodeRepresentation[]
@@ -43,15 +42,16 @@ export const mul: Operator;
 export const div: Operator;
 export const remainder: Operator;
 export const equal: Operator;
-export const assign: Operator;
 export const lessThan: Operator;
 export const greaterThan: Operator;
 export const lessThanEqual: Operator;
 export const greaterThanEqual: Operator;
 export const and: Operator;
 export const or: Operator;
+export const not: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 export const xor: Operator;
 export const bitAnd: Operator;
+export const bitNot: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 export const bitOr: Operator;
 export const bitXor: Operator;
 export const shiftLeft: Operator;
@@ -65,15 +65,16 @@ declare module '../shadernode/ShaderNode.js' {
         div: typeof div;
         remainder: typeof remainder;
         equal: typeof equal;
-        assign: typeof assign;
         lessThan: typeof lessThan;
         greaterThan: typeof greaterThan;
         lessThanEqual: typeof lessThanEqual;
         greaterThanEqual: typeof greaterThanEqual;
         and: typeof and;
         or: typeof or;
+        not: typeof not;
         xor: typeof xor;
         bitAnd: typeof bitAnd;
+        bitNot: typeof bitNot;
         bitOr: typeof bitOr;
         bitXor: typeof bitXor;
         shiftLeft: typeof shiftLeft;

three/examples/jsm/nodes/math/TriNoise3D.d.ts

@@ -0,0 +1,12 @@
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+
+export const tri: (x: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const tri3: (p: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const triNoise3D: (
+    p_immutable: NodeRepresentation,
+    spd: NodeRepresentation,
+    time: NodeRepresentation,
+) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/procedural/CheckerNode.d.ts

@@ -7,3 +7,9 @@ export default class CheckerNode extends TempNode {
 }
 
 export const checker: (uvNode?: NodeRepresentation) => ShaderNodeObject<CheckerNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        checker: typeof checker;
+    }
+}

three/examples/jsm/nodes/shadernode/ShaderNode.d.ts

@@ -1,15 +1,51 @@
 import Node from '../core/Node.js';
-import { NodeTypeOption, SwizzleOption } from '../core/constants.js';
+import { AnyObject, NodeTypeOption, SwizzleOption } from '../core/constants.js';
 import ConstNode from '../core/ConstNode.js';
 import NodeBuilder from '../core/NodeBuilder.js';
-import SplitNode from '../utils/SplitNode.js';
 
-export interface NodeElements {}
+export interface NodeElements {
+    append: typeof append;
+
+    color: typeof color;
+    float: typeof float;
+    int: typeof int;
+    uint: typeof uint;
+    bool: typeof bool;
+    vec2: typeof vec2;
+    ivec2: typeof ivec2;
+    uvec2: typeof uvec2;
+    bvec2: typeof bvec2;
+    vec3: typeof vec3;
+    ivec3: typeof ivec3;
+    uvec3: typeof uvec3;
+    bvec3: typeof bvec3;
+    vec4: typeof vec4;
+    ivec4: typeof ivec4;
+    uvec4: typeof uvec4;
+    bvec4: typeof bvec4;
+    mat2: typeof mat2;
+    imat2: typeof imat2;
+    umat2: typeof umat2;
+    bmat2: typeof bmat2;
+    mat3: typeof mat3;
+    imat3: typeof imat3;
+    umat3: typeof umat3;
+    bmat3: typeof bmat3;
+    mat4: typeof mat4;
+    imat4: typeof imat4;
+    umat4: typeof umat4;
+    bmat4: typeof bmat4;
+    string: typeof string;
+    arrayBuffer: typeof arrayBuffer;
+
+    element: typeof element;
+    convert: typeof convert;
+}
 
 export function addNodeElement(name: string, nodeElement: unknown): void;
 
 export type Swizzable<T extends Node = Node> = T & {
-    [key in SwizzleOption | number]: ShaderNodeObject<SplitNode>;
+    [key in SwizzleOption | number]: ShaderNodeObject<Node>;
 };
 
 export type ShaderNodeObject<T extends Node> = T & {
@@ -162,6 +198,13 @@ export function nodeImmutable<T>(
     ...params: ProxiedTuple<GetConstructors<T>>
 ): ShaderNodeObject<ConstructedNode<T>>;
 
+export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
+export function tslFn<T extends AnyObject, R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (args: T) => R;
+
+export function append(node: Node): Node;
+
 export const color: ConvertType;
 
 export const float: ConvertType;
@@ -184,6 +227,11 @@ export const ivec4: ConvertType;
 export const uvec4: ConvertType;
 export const bvec4: ConvertType;
 
+export const mat2: ConvertType;
+export const imat2: ConvertType;
+export const umat2: ConvertType;
+export const bmat2: ConvertType;
+
 export const mat3: ConvertType;
 export const imat3: ConvertType;
 export const umat3: ConvertType;
@@ -194,5 +242,8 @@ export const imat4: ConvertType;
 export const umat4: ConvertType;
 export const bmat4: ConvertType;
 
+export const string: (value?: string) => ShaderNodeObject<ConstNode<string>>;
+export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<ArrayBuffer>>;
+
 export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
 export const convert: (node: NodeRepresentation, types: NodeTypeOption) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/utils/DiscardNode.d.ts

@@ -0,0 +1,16 @@
+import CondNode from '../math/CondNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class DiscardNode extends CondNode {
+    constructor(condNode: Node);
+}
+
+export const inlineDiscard: (condNode: NodeRepresentation) => ShaderNodeObject<DiscardNode>;
+export const discard: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        discard: typeof discard;
+    }
+}

three/examples/jsm/nodes/utils/ReflectorNode.d.ts

@@ -0,0 +1,30 @@
+import { Camera, Object3D, RenderTarget } from '../../../../src/Three.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export interface ReflectorNodeParameters {
+    target?: Object3D | undefined;
+    resolution?: number | undefined;
+    generateMipmaps?: boolean | undefined;
+    bounces?: boolean | undefined;
+}
+
+export default class ReflectorNode extends TextureNode {
+    target: Object3D;
+    resolution: number;
+    generateMipmaps: boolean;
+    bounces: boolean;
+
+    virtualCameras: WeakMap<Camera, Camera>;
+    renderTargets: WeakMap<Camera, RenderTarget>;
+
+    constructor(parameters?: ReflectorNodeParameters);
+
+    getTextureNode(): TextureNode;
+
+    getVirtualCamera(camera: Camera): Camera;
+
+    getRenderTarget(camera: Camera): RenderTarget;
+}
+
+export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;

three/examples/jsm/nodes/utils/RemapNode.d.ts

@@ -1,5 +1,5 @@
 import Node from '../core/Node.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RemapNode extends Node {
     node: Node;
@@ -10,8 +10,27 @@ export default class RemapNode extends Node {
 
     doClamp: boolean;
 
-    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode: Node, outHighNode: Node);
+    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode?: Node, outHighNode?: Node);
 }
 
-export const remap: (node: Node, inLowNode: Node) => ShaderNodeObject<RemapNode>;
-export const remapClamp: (node: Node, inLowNode: Node) => ShaderNodeObject<RemapNode>;
+export const remap: (
+    node: Node,
+    inLowNode: NodeRepresentation,
+    inHighNode: NodeRepresentation,
+    outLowNode?: NodeRepresentation,
+    outHighNode?: NodeRepresentation,
+) => ShaderNodeObject<RemapNode>;
+export const remapClamp: (
+    node: Node,
+    inLowNode: NodeRepresentation,
+    inHighNode: NodeRepresentation,
+    outLowNode?: NodeRepresentation,
+    outHighNode?: NodeRepresentation,
+) => ShaderNodeObject<RemapNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        remap: typeof remap;
+        remapClamp: typeof remapClamp;
+    }
+}

three/examples/jsm/nodes/utils/RotateNode.d.ts

@@ -0,0 +1,21 @@
+import TempNode from '../core/TempNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class RotateNode extends TempNode {
+    positionNode: Node;
+    rotationNode: Node;
+
+    constructor(positionNode: Node, rotationNode: Node);
+}
+
+export const rotate: (
+    positionNode: NodeRepresentation,
+    rotationNode: NodeRepresentation,
+) => ShaderNodeObject<RotateNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        rotate: typeof rotate;
+    }
+}

three/examples/jsm/nodes/utils/RotateUVNode.d.ts

@@ -11,3 +11,9 @@ export default class RotateUVNode extends TempNode {
 }
 
 export const rotateUV: (uvNode: Node, rotationNode: Node, centerNode?: Node) => ShaderNodeObject<RotateUVNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        rotateUV: typeof rotateUV;
+    }
+}

three/examples/jsm/nodes/utils/TriplanarTexturesNode.d.ts

@@ -35,3 +35,9 @@ export const triplanarTexture: (
     texture: NodeRepresentation,
     ...params: NodeRepresentation[]
 ) => ShaderNodeObject<TriplanarTexturesNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        triplanarTexture: typeof triplanarTexture;
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Mesh, MeshBasicMaterial, SphereGeometry, Texture } from '../../../src/Three.js';
+
+export class GroundedSkybox extends Mesh<SphereGeometry, MeshBasicMaterial> {
+    constructor(map: Texture, height: number, radius: number, resolution?: number);
+}

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

@@ -6,8 +6,10 @@ export default class QuadMesh {
 
     dispose(): void;
 
-    render(renderer: Renderer): void;
+    renderAsync(renderer: Renderer): Promise<void>;
 
     get material(): Material;
     set material(value: Material);
+
+    get render(): (renderer: Renderer) => Promise<void>;
 }

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

@@ -61,6 +61,8 @@ export class GTAOPass extends Pass {
         parameters?: { depthTexture?: DepthTexture | undefined; normalTexture?: Texture | undefined } | undefined,
     );
 
+    get gtaoMap(): Texture;
+
     setGBuffer(depthTexture?: DepthTexture | undefined, normalTexture?: Texture | undefined): void;
 
     setSceneClipBox(box: Box3): void;
@@ -108,6 +110,7 @@ export class GTAOPass extends Pass {
     generateNoise(size?: number): DataTexture;
 
     static OUTPUT: {
+        Off: -1;
         Default: 0;
         Diffuse: 1;
         Depth: 2;

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

@@ -27,7 +27,7 @@ export class SSAOPass extends Pass {
     scene: Scene;
     camera: Camera;
     width: number;
-    height: boolean;
+    height: number;
     clear: boolean;
     kernelRadius: number;
     kernel: Vector3[];

three/examples/jsm/renderers/common/Backend.d.ts

@@ -1,13 +1,17 @@
 import { CoordinateSystem } from '../../../../src/Three.js';
 import Renderer from './Renderer.js';
 
+export interface BackendParameters {
+    canvas?: HTMLCanvasElement | undefined;
+}
+
 export default abstract class Backend {
     renderer: Renderer | null;
     domElement: HTMLCanvasElement | null;
 
-    constructor(parameters?: { canvas?: HTMLCanvasElement | undefined });
+    constructor(parameters?: BackendParameters);
 
-    init(renderer: Renderer): Promise<void>;
+    init(renderer: Renderer): void;
 
     abstract get coordinateSystem(): CoordinateSystem;
 

three/examples/jsm/renderers/common/Color4.d.ts

@@ -0,0 +1,9 @@
+import { Color, ColorRepresentation } from '../../../../src/math/Color.ts';
+
+export default class Color4 extends Color {
+    constructor(r: number, g: number, b: number, a?: number);
+
+    set(...args: [color: ColorRepresentation] | [r: number, g: number, b: number, a?: number]): this;
+
+    clone(): this;
+}

three/examples/jsm/renderers/common/Info.d.ts

@@ -8,12 +8,18 @@ export default class Info {
 
     render: { calls: number; drawCalls: number; triangles: number; points: number; lines: number };
 
-    compute: { calls: number };
+    compute: { calls: number; computeCalls: number };
 
     memory: { geometries: number; textures: number };
 
+    timestamp: { compute: number; render: number };
+
     update(object: Object3D, count: number, instanceCount: number): void;
 
+    updateTimestamp(type: keyof typeof this.timestamp, time: number): void;
+
+    resetCompute(): void;
+
     reset(): void;
 
     dispose(): void;

three/examples/jsm/renderers/common/PostProcessing.d.ts

@@ -0,0 +1,11 @@
+import Renderer from './Renderer.js';
+import { Node } from '../../nodes/Nodes.js';
+
+export default class PostProcessing {
+    renderer: Renderer;
+    outputNode: Node;
+
+    constructor(renderer: Renderer, outputNode?: Node);
+
+    render(): Promise<void>;
+}