@divinevoxel/vlox 0.0.75 → 0.0.77

package/Builder/Tools/Path/PahtTool.js

@@ -0,0 +1,128 @@
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+import { VoxelPath, VoxelPathSegment } from "../../../Templates/Path/VoxelPath";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+export var PathToolModes;
+(function (PathToolModes) {
+    PathToolModes["PlacePoints"] = "Place Points";
+    PathToolModes["MovePoints"] = "Move Points";
+    PathToolModes["RemovePoints"] = "Remove Points";
+    PathToolModes["FillPath"] = "Fill Path";
+    PathToolModes["RemovePath"] = "Remvoe Path";
+})(PathToolModes || (PathToolModes = {}));
+export class PathTool extends BuilderToolBase {
+    static ToolId = "Path";
+    static ModeArray = [
+        PathToolModes.PlacePoints,
+        PathToolModes.MovePoints,
+        PathToolModes.RemovePoints,
+        PathToolModes.FillPath,
+        PathToolModes.RemovePath,
+    ];
+    mode = PathToolModes.PlacePoints;
+    selection = new VoxelPointSelection();
+    pointSelection = new FreePointSelection(this.space, this.selection);
+    path = new VoxelPath(VoxelPath.CreateNew({}));
+    get distance() {
+        return this.pointSelection.distance;
+    }
+    set distance(value) {
+        this.pointSelection.distance = value;
+    }
+    voxelData;
+    _placedSegment = false;
+    setMode(mode) {
+        const lastMode = this.mode;
+        this.mode = mode;
+        if (lastMode == PathToolModes.PlacePoints) {
+            for (const segment of this.path.segments) {
+                if (segment.transient) {
+                    this.path.removeSegment(segment);
+                }
+            }
+        }
+        if (mode == PathToolModes.PlacePoints && this.path.segments.length) {
+            const point = this.path.lastSegment().getPoint(1);
+            this._placedSegment = false;
+            this.path.addSegment(VoxelPathSegment.CreateNew({
+                transient: true,
+                start: [...point],
+                end: [
+                    this.selection.origin.x,
+                    this.selection.origin.y,
+                    this.selection.origin.z,
+                ],
+            }));
+        }
+    }
+    cancel() {
+        this._lastPicked = null;
+    }
+    async update() {
+        if (this.mode == PathToolModes.PlacePoints) {
+            const updated = this.pointSelection.update();
+            if (!updated)
+                return;
+            const last = this.path.lastSegment();
+            if (last) {
+                last.setPoints(last.start, [
+                    this.selection.origin.x,
+                    this.selection.origin.y,
+                    this.selection.origin.z,
+                ]);
+            }
+            return;
+        }
+    }
+    async use() {
+        if (this.mode == PathToolModes.PlacePoints) {
+            this._placedSegment = true;
+            if (!this.path.totalSegments) {
+                this.path.addSegment(VoxelPathSegment.CreateNew({
+                    transient: true,
+                    start: [
+                        this.selection.origin.x,
+                        this.selection.origin.y,
+                        this.selection.origin.z,
+                    ],
+                    end: [
+                        this.selection.origin.x,
+                        this.selection.origin.y,
+                        this.selection.origin.z,
+                    ],
+                }));
+            }
+            else {
+                const lastSegment = this.path.lastSegment();
+                lastSegment.transient = false;
+                this.path.addSegment(VoxelPathSegment.CreateNew({
+                    transient: true,
+                    start: [...lastSegment.end],
+                    end: [
+                        this.selection.origin.x,
+                        this.selection.origin.y,
+                        this.selection.origin.z,
+                    ],
+                }));
+            }
+        }
+        if (this.mode == PathToolModes.FillPath) {
+            for (const segment of this.path.segments) {
+                segment.voxel = this.voxelData;
+            }
+            await this.space.paintPath([0, 0, 0], this.path.toJSON());
+            return;
+        }
+        if (this.mode == PathToolModes.RemovePath) {
+            await this.space.erasePath([0, 0, 0], this.path.toJSON());
+            return;
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Tools/Sculpt/SculptTool.d.ts

@@ -0,0 +1,34 @@
+import { VoxelBuildSpace } from "../../VoxelBuildSpace";
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelBoundsSelection } from "../../../Templates/Selection/VoxelBoundsSelection";
+import { Vector3Like } from "@amodx/math";
+import { SurfaceBoxSelection } from "../../Util/SurfaceBoxSelection";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+export declare enum SculptToolModes {
+    Fill = "Fill",
+    Extrude = "Extrude",
+    Remove = "Remove"
+}
+interface SculptToolEvents {
+}
+export declare class SculptTool extends BuilderToolBase<SculptToolEvents> {
+    static ToolId: string;
+    static ModeArray: SculptToolModes[];
+    mode: SculptToolModes;
+    selection: VoxelBoundsSelection;
+    boxSelection: SurfaceBoxSelection;
+    voxelData: PaintVoxelData;
+    usePlacingStrategy: boolean;
+    constructor(space: VoxelBuildSpace);
+    cancel(): void;
+    private _started;
+    isSelectionStarted(): boolean;
+    updateOffset(offset: number): void;
+    _normal: Vector3Like;
+    update(placerMode?: "start" | "end" | null): Promise<void>;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};

package/Builder/Tools/Sculpt/SculptTool.js

@@ -0,0 +1,102 @@
+import { VoxelBoundsSelection } from "../../../Templates/Selection/VoxelBoundsSelection";
+import { Vector3Like } from "@amodx/math";
+import { SurfaceBoxSelection } from "../../Util/SurfaceBoxSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+export var SculptToolModes;
+(function (SculptToolModes) {
+    SculptToolModes["Fill"] = "Fill";
+    SculptToolModes["Extrude"] = "Extrude";
+    SculptToolModes["Remove"] = "Remove";
+})(SculptToolModes || (SculptToolModes = {}));
+export class SculptTool extends BuilderToolBase {
+    static ToolId = "Sculpt";
+    static ModeArray = [
+        SculptToolModes.Fill,
+        SculptToolModes.Extrude,
+        SculptToolModes.Remove,
+    ];
+    mode = SculptToolModes.Fill;
+    selection = new VoxelBoundsSelection();
+    boxSelection;
+    voxelData;
+    usePlacingStrategy = true;
+    constructor(space) {
+        super(space);
+        this.boxSelection = new SurfaceBoxSelection(this.space, this.selection);
+    }
+    cancel() {
+        this._started = false;
+    }
+    _started = false;
+    isSelectionStarted() {
+        return this._started;
+    }
+    updateOffset(offset) {
+        this.boxSelection.offset = offset;
+        this.boxSelection.update();
+    }
+    _normal;
+    async update(placerMode = null) {
+        const picked = this.isSelectionStarted()
+            ? null
+            : await this.space.pickWithProvider(this.rayProviderIndex);
+        this._lastPicked = picked;
+        if (!this._started && !placerMode && picked) {
+            if (this.mode == SculptToolModes.Fill ||
+                this.mode == SculptToolModes.Extrude) {
+                this.selection.reConstruct(picked.normalPosition, picked.normal, Vector3Like.Add(picked.normalPosition, Vector3Like.Create(1, 1, 1)), picked.normal);
+            }
+            if (this.mode == SculptToolModes.Remove) {
+                this.selection.reConstruct(picked.position, picked.normal, Vector3Like.Add(picked.position, Vector3Like.Create(1, 1, 1)), picked.normal);
+            }
+            this._normal = { ...picked.normal };
+        }
+        if (!this._started && placerMode == "start" && picked) {
+            this.boxSelection.offset = 0;
+            Vector3Like.Copy(this.boxSelection.planeNormal, picked.normal);
+            if (this.mode == SculptToolModes.Fill ||
+                this.mode == SculptToolModes.Extrude) {
+                Vector3Like.Copy(this.boxSelection.planeOrigin, picked.normalPosition);
+            }
+            if (this.mode == SculptToolModes.Remove) {
+                Vector3Like.Copy(this.boxSelection.planeOrigin, picked.position);
+            }
+            this.boxSelection.update();
+            this._started = true;
+            return;
+        }
+        if (this._started && !placerMode && !picked) {
+            this.boxSelection.update();
+            return;
+        }
+        if (this._started && placerMode == "end") {
+            this.boxSelection.update();
+            this._started = false;
+        }
+    }
+    async use() {
+        if (this.mode == SculptToolModes.Fill) {
+            await this.space.paintTemplate(Vector3Like.ToArray(this.selection.origin), this.selection
+                .toTemplate({
+                fillVoxel: this.voxelData,
+            })
+                .toJSON());
+            return;
+        }
+        if (this.mode == SculptToolModes.Extrude) {
+            const template = await this.space.getExtrudedSelectionTemplate(this.selection.toJSON(), this._normal);
+            await this.space.paintTemplate(this.selection.origin, template.toJSON());
+            return;
+        }
+        if (this.mode == SculptToolModes.Remove) {
+            await this.space.eraseTemplate(Vector3Like.ToArray(this.selection.origin), this.selection.toTemplate({}).toJSON());
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Tools/Shape/ShapeTool.d.ts

@@ -0,0 +1,32 @@
+import { PaintVoxelData } from "../../../Voxels";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+import { FreeBoxSelection } from "../../Util/FreeBoxSelection";
+export declare enum ShapeToolModes {
+    Fill = "Fill",
+    Remove = "Remove"
+}
+interface BoxToolEvents {
+}
+export declare class ShapeTool extends BuilderToolBase<BoxToolEvents> {
+    static ToolId: string;
+    static ModeArray: ShapeToolModes[];
+    mode: ShapeToolModes;
+    selection: VoxelPointSelection;
+    pointSelection: FreePointSelection;
+    boxSelection: FreeBoxSelection | null;
+    voxelData: PaintVoxelData;
+    usePlacingStrategy: boolean;
+    get distance(): number;
+    set distance(distance: number);
+    private _started;
+    isSelectionStarted(): boolean;
+    cancel(): void;
+    update(placerMode?: "start" | "end" | null): Promise<void>;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};

package/Builder/Tools/Shape/ShapeTool.js

@@ -0,0 +1,78 @@
+import { Vector3Like } from "@amodx/math";
+import { BuilderToolBase } from "../BuilderToolBase";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+import { FreeBoxSelection } from "../../Util/FreeBoxSelection";
+export var ShapeToolModes;
+(function (ShapeToolModes) {
+    ShapeToolModes["Fill"] = "Fill";
+    ShapeToolModes["Remove"] = "Remove";
+})(ShapeToolModes || (ShapeToolModes = {}));
+export class ShapeTool extends BuilderToolBase {
+    static ToolId = "Shape";
+    static ModeArray = [
+        ShapeToolModes.Fill,
+        ShapeToolModes.Remove,
+    ];
+    mode = ShapeToolModes.Fill;
+    selection = new VoxelPointSelection();
+    pointSelection = new FreePointSelection(this.space, this.selection);
+    boxSelection = null;
+    voxelData;
+    usePlacingStrategy = true;
+    get distance() {
+        return this.pointSelection.distance;
+    }
+    set distance(distance) {
+        if (this.boxSelection)
+            this.pointSelection.distance = distance;
+    }
+    _started = false;
+    isSelectionStarted() {
+        return this._started;
+    }
+    cancel() {
+        this._started = false;
+        this.boxSelection = null;
+    }
+    async update(placerMode = null) {
+        if (this.boxSelection) {
+            this.boxSelection.update();
+        }
+        else {
+            this.pointSelection.update();
+        }
+        if (placerMode == "start") {
+            this._started = true;
+            this.boxSelection = new FreeBoxSelection(this.space, this.pointSelection);
+        }
+        if (placerMode == "end") {
+            this._started = false;
+        }
+    }
+    async use() {
+        if (!this.boxSelection)
+            return;
+        if (this.mode == ShapeToolModes.Fill) {
+            await this.space.paintTemplate(Vector3Like.ToArray(this.boxSelection.selection.origin), this.boxSelection.selection
+                .toTemplate({
+                fillVoxel: this.voxelData,
+            })
+                .toJSON());
+            this.boxSelection = null;
+            return;
+        }
+        if (this.mode == ShapeToolModes.Remove) {
+            await this.space.eraseTemplate(Vector3Like.ToArray(this.boxSelection.selection.origin), this.boxSelection.selection.toTemplate({}).toJSON());
+            this.boxSelection = null;
+            return;
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Tools/Template/TemplateTool.d.ts

@@ -0,0 +1,35 @@
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+import { VoxelBoundsSelection } from "../../../Templates/Selection/VoxelBoundsSelection";
+import { FreeBoxSelection } from "../../Util/FreeBoxSelection";
+import { FullVoxelTemplate } from "../../../Templates/Full/FullVoxelTemplate";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+export declare enum TemplateToolModes {
+    Select = "Select",
+    Place = "Place",
+    Remove = "Remove"
+}
+interface TemplateToolEvents {
+    "selection-created": VoxelBoundsSelection;
+}
+export declare class TemplateTool extends BuilderToolBase<TemplateToolEvents> {
+    static ToolId: string;
+    static ModeArray: TemplateToolModes[];
+    mode: TemplateToolModes;
+    selection: VoxelPointSelection;
+    pointSelection: FreePointSelection;
+    boxSelection: FreeBoxSelection | null;
+    usePlacingStrategy: boolean;
+    get distance(): number;
+    set distance(distance: number);
+    private _started;
+    selectionToTemplate(selection: VoxelBoundsSelection): Promise<FullVoxelTemplate>;
+    isSelectionStarted(): boolean;
+    update(placerMode?: "start" | "end" | null): Promise<void>;
+    cancel(): void;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};

package/Builder/Tools/Template/TemplateTool.js

@@ -0,0 +1,73 @@
+import { BuilderToolBase } from "../BuilderToolBase";
+import { FreeBoxSelection } from "../../Util/FreeBoxSelection";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+export var TemplateToolModes;
+(function (TemplateToolModes) {
+    TemplateToolModes["Select"] = "Select";
+    TemplateToolModes["Place"] = "Place";
+    TemplateToolModes["Remove"] = "Remove";
+})(TemplateToolModes || (TemplateToolModes = {}));
+export class TemplateTool extends BuilderToolBase {
+    static ToolId = "Template";
+    static ModeArray = [
+        TemplateToolModes.Select,
+        TemplateToolModes.Place,
+        TemplateToolModes.Remove,
+    ];
+    mode = TemplateToolModes.Select;
+    selection = new VoxelPointSelection();
+    pointSelection = new FreePointSelection(this.space, this.selection);
+    boxSelection = null;
+    usePlacingStrategy = true;
+    get distance() {
+        return this.pointSelection.distance;
+    }
+    set distance(distance) {
+        if (this.boxSelection)
+            this.pointSelection.distance = distance;
+    }
+    _started = false;
+    async selectionToTemplate(selection) {
+        const bounds = selection.bounds.getMinMax();
+        return await this.space.createTemplate(bounds);
+    }
+    isSelectionStarted() {
+        return this._started;
+    }
+    async update(placerMode = null) {
+        if (this.boxSelection) {
+            this.boxSelection.update();
+        }
+        else {
+            this.pointSelection.update();
+        }
+        if (placerMode == "start") {
+            this._started = true;
+            this.boxSelection = new FreeBoxSelection(this.space, this.pointSelection);
+        }
+        if (placerMode == "end") {
+            this._started = false;
+            this.boxSelection = null;
+        }
+    }
+    cancel() {
+        this._started = false;
+        this._lastPicked = null;
+        this.boxSelection = null;
+    }
+    async use() {
+        if (!this.boxSelection)
+            return;
+        if (this.mode == TemplateToolModes.Select) {
+            this.dispatch("selection-created", this.boxSelection.selection);
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Tools/Wand/WandTool.d.ts

@@ -0,0 +1,30 @@
+import { PaintVoxelData } from "../../../Voxels/Types/PaintVoxelData";
+import { VoxelSurfaceSelection } from "../../../Templates/Selection/VoxelSurfaceSelection";
+import { VoxelBFSSelection } from "../../../Templates/Selection/VoxelBFSSelection";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+export declare enum WandToolModes {
+    Place = "Place",
+    Extrude = "Extrude",
+    Remove = "Remove"
+}
+interface WandToolEvents {
+}
+export declare class WandTool extends BuilderToolBase<WandToolEvents> {
+    static ToolId: string;
+    static ModeArray: WandToolModes[];
+    mode: WandToolModes;
+    maxCount: number;
+    extrusion: number;
+    get selection(): VoxelSurfaceSelection | VoxelBFSSelection;
+    surfaceSelection: VoxelSurfaceSelection;
+    bfsSelection: VoxelBFSSelection;
+    voxelData: PaintVoxelData;
+    usePlacingStrategy: boolean;
+    update(): Promise<void>;
+    cancel(): void;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};

package/Builder/Tools/Wand/WandTool.js

@@ -0,0 +1,90 @@
+import { VoxelSurfaceSelection } from "../../../Templates/Selection/VoxelSurfaceSelection";
+import { VoxelBFSSelection } from "../../../Templates/Selection/VoxelBFSSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+export var WandToolModes;
+(function (WandToolModes) {
+    WandToolModes["Place"] = "Place";
+    WandToolModes["Extrude"] = "Extrude";
+    WandToolModes["Remove"] = "Remove";
+})(WandToolModes || (WandToolModes = {}));
+export class WandTool extends BuilderToolBase {
+    static ToolId = "Wand";
+    static ModeArray = [
+        WandToolModes.Place,
+        WandToolModes.Extrude,
+        WandToolModes.Remove,
+    ];
+    mode = WandToolModes.Place;
+    maxCount = 1000;
+    extrusion = 0;
+    get selection() {
+        if (this.mode == WandToolModes.Place ||
+            this.mode == WandToolModes.Extrude) {
+            return this.surfaceSelection;
+        }
+        return this.bfsSelection;
+    }
+    surfaceSelection = new VoxelSurfaceSelection();
+    bfsSelection = new VoxelBFSSelection();
+    voxelData;
+    usePlacingStrategy = true;
+    async update() {
+        this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
+        if (!this._lastPicked)
+            return;
+        if (this.mode == WandToolModes.Place ||
+            this.mode == WandToolModes.Extrude) {
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.normalPosition)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.surfaceSelection.fromJSON(await this.space.getSurfaceSelection(this._lastPicked.position, this._lastPicked.normal, this.extrusion, this.maxCount));
+        }
+        if (this.mode == WandToolModes.Remove) {
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.bfsSelection.fromJSON(await this.space.getBFSSelection(this._lastPicked.position, this.maxCount));
+        }
+    }
+    cancel() {
+        this._lastPicked = null;
+    }
+    async use() {
+        const picked = this._lastPicked;
+        if (!picked)
+            return;
+        let voxelData = this.voxelData;
+        if (this.mode == WandToolModes.Place) {
+            if (!this.space.bounds.intersectsPoint(picked.normalPosition))
+                return;
+            if (this.usePlacingStrategy) {
+                const newData = this.space.getPlaceState(voxelData, picked);
+                if (newData)
+                    voxelData = newData;
+            }
+            this.surfaceSelection.fromJSON(await this.space.getSurfaceSelection(picked.position, picked.normal, this.extrusion, this.maxCount));
+            await this.space.paintTemplate(this.surfaceSelection.origin, this.surfaceSelection.toTemplate(voxelData).toJSON());
+            return;
+        }
+        if (this.mode == WandToolModes.Extrude) {
+            this.surfaceSelection.fromJSON(await this.space.getSurfaceSelection(picked.position, picked.normal, this.extrusion, this.maxCount));
+            const template = await this.space.getExtrudedSelectionTemplate(this.surfaceSelection.toJSON(), picked.normal);
+            await this.space.paintTemplate(this.surfaceSelection.origin, template.toJSON());
+            return;
+        }
+        if (this.mode == WandToolModes.Remove) {
+            const selection = await this.space.getBFSSelection(picked.position, this.maxCount);
+            await this.space.eraseSelection(selection);
+            return;
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Tools/Wrench/WrenchTool.d.ts

@@ -0,0 +1,47 @@
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+interface WrenchToolEvents {
+    picked: {};
+}
+export type WrenchToolVoxelScehmaNodes = {
+    type: "string";
+    values: string[];
+    id: string;
+    label: string;
+    value: string;
+} | {
+    type: "number";
+    min: number;
+    max: number;
+    id: string;
+    label: string;
+    value: number;
+};
+type WrenchToolSchemas = {
+    stateSchema: WrenchToolVoxelScehmaNodes[];
+    modSchema: WrenchToolVoxelScehmaNodes[];
+};
+export declare class WrenchTool extends BuilderToolBase<WrenchToolEvents> {
+    static ToolId: string;
+    private mode;
+    selection: VoxelPointSelection;
+    paintData: PaintVoxelData;
+    private _pickedResult;
+    isUpdating(): boolean;
+    stopUpdating(): void;
+    update(): Promise<void>;
+    private processSchema;
+    updatePickedSchema(schema: WrenchToolSchemas): PaintVoxelData | undefined;
+    getPickedSchema(): WrenchToolSchemas | null;
+    /**Get an array of all possible state varations for the current mod of the selected voxel. */
+    getStateValues(): PaintVoxelData[] | null;
+    /**Get an array of all possible mod varations for the current state of the selected voxel. */
+    getModValues(): PaintVoxelData[] | null;
+    cancel(): void;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};