@sprucelabs/spruce-cli 18.4.0 → 19.1.0

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/Login.vc.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const Authenticator_1 = __importDefault(require("../auth/Authenticator"));
+const buildBigForm_1 = __importDefault(require("../builders/buildBigForm"));
+const Abstract_vc_1 = __importDefault(require("./Abstract.vc"));
+class LoginViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.currentSlide = 0;
+        this._id = (_a = options.id) !== null && _a !== void 0 ? _a : `${LoginViewController._id}`;
+        LoginViewController._id++;
+        this.sections = [
+            {
+                title: spruce_skill_utils_1.randomUtil.rand([
+                    'What is your cell?',
+                    'Gimme a number to text.',
+                    'What is your number 👇',
+                ]),
+                fields: ['phone'],
+            },
+            {
+                title: spruce_skill_utils_1.randomUtil.rand([
+                    'Now the pin! 👇',
+                    'The pin is next!',
+                    'Time for pin.',
+                ]),
+                fields: [{ name: 'code', renderAs: 'number' }],
+                shouldShowSubmitButton: false,
+            },
+        ];
+        this.loginHandler = options.onLogin;
+        this.loginFailedHandler = options.onLoginFailed;
+        this.loginForm = this.BigForm();
+    }
+    BigForm() {
+        return this.Controller('bigForm', (0, buildBigForm_1.default)({
+            onChange: this.handleOnChange.bind(this),
+            onSubmitSlide: this.handleSubmitSlide.bind(this),
+            isBusy: false,
+            id: this._id,
+            schema: loginSchema,
+            sections: this.sections,
+        }));
+    }
+    async handleSubmitSlide({ values, presentSlide, }) {
+        this.loginForm.setIsBusy(true);
+        let response = true;
+        if (presentSlide === 0 && values.phone) {
+            response = await this.handleSubmitPhone(values.phone);
+        }
+        else if (presentSlide === 1 && values.code) {
+            await this.handleSubmitPin(values.code);
+            response = false;
+        }
+        this.loginForm.setIsBusy(false);
+        return response;
+    }
+    async handleOnChange(options) {
+        var _a;
+        if (((_a = options.values.code) === null || _a === void 0 ? void 0 : _a.length) === 4) {
+            await this.loginForm.submit();
+        }
+    }
+    async handleSubmitPhone(phone) {
+        try {
+            await this.loginForm.resetField('code');
+            const client = await this.connectToApi();
+            const [{ challenge }] = await client.emitAndFlattenResponses('request-pin::v2020_12_25', {
+                payload: {
+                    phone,
+                },
+            });
+            this.userChallenge = challenge;
+        }
+        catch (err) {
+            this.loginForm.setErrors([
+                {
+                    code: 'INVALID_PARAMETER',
+                    name: 'phone',
+                    friendlyMessage: err.message,
+                },
+            ]);
+            return false;
+        }
+        return true;
+    }
+    getIsBusy() {
+        return this.loginForm.getIsBusy();
+    }
+    async handleSubmitPin(pin) {
+        var _a, _b;
+        this.setIsBusy(true);
+        try {
+            const client = await this.connectToApi();
+            const [{ person, token }] = await client.emitAndFlattenResponses('confirm-pin::v2020_12_25', {
+                payload: {
+                    challenge: this.userChallenge,
+                    pin,
+                },
+            });
+            Authenticator_1.default.getInstance().setSessionToken(token, person);
+            await ((_a = this.loginHandler) === null || _a === void 0 ? void 0 : _a.call(this, { person }));
+        }
+        catch (err) {
+            this.loginForm.setErrors([
+                {
+                    code: 'INVALID_PARAMETER',
+                    name: 'code',
+                    friendlyMessage: "That pin doesn't look right, try again!",
+                },
+            ]);
+            (_b = this.loginFailedHandler) === null || _b === void 0 ? void 0 : _b.call(this, err);
+        }
+        this.setIsBusy(false);
+    }
+    setIsBusy(isBusy) {
+        this.loginForm.setIsBusy(isBusy);
+    }
+    getLoginForm() {
+        return this.loginForm;
+    }
+    render() {
+        return {
+            //@ts-ignore
+            controller: this,
+            id: this._id,
+            header: {
+                title: this.currentSlide === 0
+                    ? spruce_skill_utils_1.randomUtil.rand([
+                        'Get started',
+                        `Time to log in!`,
+                        `Let's do this! 💪`,
+                    ])
+                    : spruce_skill_utils_1.randomUtil.rand([
+                        'Almost there!',
+                        'Enter your pin below!',
+                        'Last step!',
+                    ]),
+                subtitle: this.currentSlide === 0
+                    ? spruce_skill_utils_1.randomUtil.rand([
+                        'Login or signup below!',
+                        "One text and one pin and you're in!",
+                        "I'm so excited!",
+                    ])
+                    : spruce_skill_utils_1.randomUtil.rand([
+                        'Last step!',
+                        `So close I can taste it!`,
+                        `You got this!`,
+                    ]),
+            },
+            body: {
+                sections: [
+                    {
+                        bigForm: this.loginForm.render(),
+                    },
+                ],
+            },
+        };
+    }
+}
+exports.default = LoginViewController;
+LoginViewController._id = 0;
+const loginSchema = (0, schema_1.buildSchema)({
+    id: 'loginSchema',
+    fields: {
+        phone: {
+            type: 'phone',
+            isRequired: true,
+            label: 'Phone',
+            hint: "I'm gonna send you a pin. Texting rates may apply.",
+        },
+        code: {
+            type: 'text',
+            isRequired: true,
+            label: 'Pin',
+            options: {},
+        },
+    },
+});

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/Map.vc.d.ts

@@ -0,0 +1,13 @@
+import { Map, MapPin, MapZoom, ViewControllerOptions } from '../types/heartwood.types';
+import AbstractViewController from './Abstract.vc';
+export default class MapViewController extends AbstractViewController<Map> {
+    private model;
+    constructor(options: ViewControllerOptions & MapViewControllerOptions);
+    getPins(): import("@sprucelabs/spruce-core-schemas").SpruceSchemas.HeartwoodViewControllers.v2021_02_11.MapPin[] | null | undefined;
+    setPins(pins: MapPin[]): void;
+    addPin(expected: MapPin): void;
+    getZoom(): "city" | "house" | "block" | "longWalk" | "shortDrive" | "state" | null | undefined;
+    setZoom(zoom: MapZoom): void;
+    render(): Map;
+}
+export type MapViewControllerOptions = Omit<Map, 'controller'>;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/Map.vc.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const removeUniversalViewOptions_1 = __importDefault(require("../utilities/removeUniversalViewOptions"));
+const Abstract_vc_1 = __importDefault(require("./Abstract.vc"));
+class MapViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        super(options);
+        this.model = (0, removeUniversalViewOptions_1.default)(options);
+    }
+    getPins() {
+        return this.model.pins;
+    }
+    setPins(pins) {
+        this.model.pins = (0, schema_1.cloneDeep)(pins);
+        this.triggerRender();
+    }
+    addPin(expected) {
+        var _a;
+        if (!this.model.pins) {
+            this.model.pins = [];
+        }
+        (_a = this.model.pins) === null || _a === void 0 ? void 0 : _a.push(expected);
+        this.triggerRender();
+    }
+    getZoom() {
+        return this.model.zoom;
+    }
+    setZoom(zoom) {
+        this.model.zoom = zoom;
+        this.triggerRender();
+    }
+    render() {
+        return Object.assign(Object.assign({}, this.model), { controller: this });
+    }
+}
+exports.default = MapViewController;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/Ratings.vc.d.ts

@@ -0,0 +1,18 @@
+import { SpruceSchemas, ViewControllerOptions } from '..';
+import AbstractViewController from './Abstract.vc';
+type Ratings = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Ratings;
+export type RatingsViewControllerOptions = Ratings;
+export default class RatingsViewController extends AbstractViewController<Ratings> {
+    private model;
+    constructor(options: ViewControllerOptions & Ratings);
+    private assertValidRenderAs;
+    private assertValueInRange;
+    setRenderAs(renderAs: NonNullable<Ratings['renderAs']>): void;
+    getRenderAs(): "stars" | "smilies" | null | undefined;
+    setCanBeChanged(canBeChanged: boolean): void;
+    getCanBeChanged(): boolean;
+    setValue(value: number): void;
+    getValue(): number | null | undefined;
+    render(): Ratings;
+}
+export {};

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/Ratings.vc.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const Abstract_vc_1 = __importDefault(require("./Abstract.vc"));
+class RatingsViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        super(options);
+        const value = options.value;
+        const renderAs = options.renderAs;
+        this.assertValidRenderAs(renderAs);
+        this.assertValueInRange(value);
+        this.model = Object.assign({ canBeChanged: false }, options);
+    }
+    assertValidRenderAs(renderAs) {
+        if (renderAs && renderAs !== 'stars' && renderAs !== 'smilies') {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['renderAs'],
+                friendlyMessage: `Render as can only be 'stars' or 'smilies'.`,
+            });
+        }
+    }
+    assertValueInRange(value) {
+        if (value && (value < 0 || value > 1)) {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['value'],
+                friendlyMessage: 'Rating value must be between zero and one.',
+            });
+        }
+    }
+    setRenderAs(renderAs) {
+        this.assertValidRenderAs(renderAs);
+        this.model.renderAs = renderAs;
+        this.triggerRender();
+    }
+    getRenderAs() {
+        return this.model.renderAs;
+    }
+    setCanBeChanged(canBeChanged) {
+        this.model.canBeChanged = canBeChanged;
+    }
+    getCanBeChanged() {
+        var _a;
+        return (_a = this.model.canBeChanged) !== null && _a !== void 0 ? _a : false;
+    }
+    setValue(value) {
+        var _a, _b;
+        this.assertValueInRange(value);
+        this.model.value = value;
+        (_b = (_a = this.model).onChange) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+        this.triggerRender();
+    }
+    getValue() {
+        return this.model.value;
+    }
+    render() {
+        return Object.assign({ 
+            //@ts-ignore
+            controller: this }, this.model);
+    }
+}
+exports.default = RatingsViewController;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/SwipeCard.vc.d.ts

@@ -0,0 +1,42 @@
+import { Card, CardFooter, Slide, ViewControllerOptions } from '../types/heartwood.types';
+import AbstractViewController from './Abstract.vc';
+import CardViewController from './card/Card.vc';
+export type SwipeViewControllerOptions = {
+    slides: Slide[];
+    onSlideChange?: (slide: number) => void;
+    isBusy?: boolean;
+} & Omit<Card, 'body'>;
+declare const PASSTHROUGH_METHODS: readonly ["setHeaderTitle", "setHeaderSubtitle"];
+type PassthroughMethods = {
+    [K in (typeof PASSTHROUGH_METHODS)[number]]: CardViewController[K];
+};
+/** @ts-ignore */
+export default class SwipeCardViewController extends AbstractViewController<Card> implements PassthroughMethods {
+    private presentSlide;
+    private swipeController?;
+    private slideChangeHandler;
+    static swipeDelay: number;
+    private cardVc;
+    setHeaderTitle: CardViewController['setHeaderTitle'];
+    setHeaderSubtitle: CardViewController['setHeaderSubtitle'];
+    setSections: CardViewController['setSections'];
+    private cardBeforeNull?;
+    constructor(options: SwipeViewControllerOptions & ViewControllerOptions);
+    jumpToSlide(slide: number): Promise<void>;
+    private handleSlideChange;
+    getPresentSlide(): number;
+    setSlide(idOrIdx: number | string, slide: Partial<Slide>): void;
+    updateSlide(idOrIdx: number | string, updates: Partial<Slide>): void;
+    private assertSlideExists;
+    markSlideAsComplete(slideIdx: number): void;
+    getSlides(): import("@sprucelabs/spruce-core-schemas").SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CardSection[] | null | undefined;
+    removeSlide(idx: number): void;
+    addSlideAtIndex(idx: number, slide: Slide): void;
+    addSlide(slide: Slide): void;
+    getSlide(idOrIdx: number | string): import("@sprucelabs/spruce-core-schemas").SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CardSection;
+    setFooter(footer: CardFooter | null | undefined): void;
+    setShouldRenderNull(shouldRenderNull: boolean): void;
+    getTotalSlides(): number;
+    render(): Card;
+}
+export {};

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/SwipeCard.vc.js

@@ -0,0 +1,138 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
+const Abstract_vc_1 = __importDefault(require("./Abstract.vc"));
+const sectionIdOrIdxToIdx_1 = __importDefault(require("./card/sectionIdOrIdxToIdx"));
+const PASSTHROUGH_METHODS = ['setHeaderTitle', 'setHeaderSubtitle'];
+/** @ts-ignore */
+class SwipeCardViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        super(options);
+        this.presentSlide = 0;
+        const { slides, onSlideChange, isBusy } = options, rest = __rest(options, ["slides", "onSlideChange", "isBusy"]);
+        this.slideChangeHandler = onSlideChange;
+        this.cardVc = this.Controller('card', Object.assign(Object.assign({}, rest), { body: {
+                isBusy,
+                sections: slides,
+                swipeController: (controller) => (this.swipeController = controller),
+                onSelectSlideTitle: this.jumpToSlide.bind(this),
+                onChangeSlide: this.handleSlideChange.bind(this),
+                shouldEnableSectionSwiping: true,
+            } }));
+        spruce_skill_utils_1.functionDelegationUtil.delegateFunctionCalls(this, this.cardVc);
+        this.cardVc.triggerRender = () => {
+            this.triggerRender();
+        };
+    }
+    async jumpToSlide(slide) {
+        var _a;
+        if (typeof slide !== 'number') {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['slideIndex'],
+            });
+        }
+        (_a = this.swipeController) === null || _a === void 0 ? void 0 : _a.swipeTo(slide);
+        await this.handleSlideChange(slide);
+    }
+    async handleSlideChange(slide) {
+        if (this.presentSlide !== slide) {
+            this.presentSlide = slide;
+            await new Promise((resolve) => {
+                setTimeout(() => {
+                    var _a;
+                    (_a = this.slideChangeHandler) === null || _a === void 0 ? void 0 : _a.call(this, slide);
+                    resolve();
+                }, SwipeCardViewController.swipeDelay);
+            });
+        }
+    }
+    getPresentSlide() {
+        return this.presentSlide;
+    }
+    setSlide(idOrIdx, slide) {
+        const idx = (0, sectionIdOrIdxToIdx_1.default)(this.getSlides(), idOrIdx);
+        this.assertSlideExists(idx, idOrIdx);
+        return this.cardVc.setSection(idx, slide);
+    }
+    updateSlide(idOrIdx, updates) {
+        const idx = (0, sectionIdOrIdxToIdx_1.default)(this.getSlides(), idOrIdx);
+        this.assertSlideExists(idx, idOrIdx);
+        this.cardVc.updateSection(idx, updates);
+    }
+    assertSlideExists(slide, idOrIdx) {
+        var _a;
+        if (!((_a = this.getSlides()) === null || _a === void 0 ? void 0 : _a[slide])) {
+            throw new schema_1.SchemaError({
+                code: 'INVALID_PARAMETERS',
+                parameters: ['slide'],
+                friendlyMessage: `I couldn't update slide ${idOrIdx} because it doesn't exist.`,
+            });
+        }
+    }
+    markSlideAsComplete(slideIdx) {
+        this.assertSlideExists(slideIdx, slideIdx);
+        const section = this.cardVc.getSection(slideIdx);
+        section.isComplete = true;
+    }
+    getSlides() {
+        return this.cardVc.getSections();
+    }
+    removeSlide(idx) {
+        return this.cardVc.removeSection(idx);
+    }
+    addSlideAtIndex(idx, slide) {
+        return this.cardVc.addSectionAtIndex(idx, slide);
+    }
+    addSlide(slide) {
+        return this.cardVc.addSection(slide);
+    }
+    getSlide(idOrIdx) {
+        return this.cardVc.getSection(idOrIdx);
+    }
+    setFooter(footer) {
+        this.cardVc.setFooter(footer);
+    }
+    setShouldRenderNull(shouldRenderNull) {
+        var _a, _b, _c;
+        if (shouldRenderNull) {
+            this.cardBeforeNull = {
+                header: this.cardVc.getHeader(),
+                body: this.cardVc.getBody(),
+                footer: this.cardVc.getFooter(),
+            };
+            this.cardVc.setHeader(null);
+            this.cardVc.setBody(null);
+            this.cardVc.setFooter(null);
+        }
+        else {
+            this.cardVc.setHeader((_a = this.cardBeforeNull) === null || _a === void 0 ? void 0 : _a.header);
+            this.cardVc.setBody((_b = this.cardBeforeNull) === null || _b === void 0 ? void 0 : _b.body);
+            this.cardVc.setFooter((_c = this.cardBeforeNull) === null || _c === void 0 ? void 0 : _c.footer);
+        }
+    }
+    getTotalSlides() {
+        return this.cardVc.getTotalSections();
+    }
+    render() {
+        //@ts-ignore
+        return Object.assign(Object.assign({}, this.cardVc.render()), { controller: this });
+    }
+}
+exports.default = SwipeCardViewController;
+SwipeCardViewController.swipeDelay = 500;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/TalkingSprucebot.vc.d.ts

@@ -0,0 +1,23 @@
+import { SpruceSchemas } from '@sprucelabs/mercury-types';
+import { ViewController, ViewControllerOptions } from '../types/heartwood.types';
+import AbstractViewController from './Abstract.vc';
+export default class TalkingSprucebotViewController extends AbstractViewController<ViewModel> implements ViewController<ViewModel> {
+    private model;
+    private playResolver?;
+    constructor(options: TalkingSprucebotViewControllerOptions & ViewControllerOptions);
+    private playHandler;
+    private restartHandler;
+    private pauseHandler;
+    private triggerComplete;
+    play(): Promise<void>;
+    restart(): void;
+    pause(): void;
+    getIsPlaying(): boolean;
+    setSentences(sentences: Sentence[]): void;
+    render(): ViewModel;
+}
+type ViewModel = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.TalkingSprucebot;
+export type Sentence = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.SprucebotTypedMessageSentence;
+export interface TalkingSprucebotViewControllerOptions extends ViewModel {
+}
+export {};

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/TalkingSprucebot.vc.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const Abstract_vc_1 = __importDefault(require("./Abstract.vc"));
+class TalkingSprucebotViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        var _a;
+        super(options);
+        if (!((_a = options.sentences[0]) === null || _a === void 0 ? void 0 : _a.words)) {
+            throw new schema_1.SchemaError({
+                code: 'MISSING_PARAMETERS',
+                parameters: ['sentences'],
+            });
+        }
+        this.model = Object.assign({ avatar: {
+                stateOfMind: 'chill',
+            }, size: 'medium' }, options);
+    }
+    playHandler() { }
+    restartHandler() { }
+    pauseHandler() { }
+    //@ts-ignore
+    async triggerComplete() {
+        var _a, _b, _c;
+        await ((_b = (_a = this.model).onComplete) === null || _b === void 0 ? void 0 : _b.call(_a));
+        (_c = this.playResolver) === null || _c === void 0 ? void 0 : _c.call(this);
+    }
+    async play() {
+        this.model.isPlaying = true;
+        this.playHandler();
+        return new Promise((resolve) => {
+            this.playResolver = resolve;
+        });
+    }
+    restart() {
+        this.restartHandler();
+    }
+    pause() {
+        this.model.isPlaying = false;
+        this.pauseHandler();
+    }
+    getIsPlaying() {
+        return this.model.isPlaying !== false;
+    }
+    setSentences(sentences) {
+        this.model.sentences = sentences;
+        this.triggerRender();
+    }
+    render() {
+        //@ts-ignore
+        return Object.assign(Object.assign({}, this.model), { controller: this });
+    }
+}
+exports.default = TalkingSprucebotViewController;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/viewControllers/ToolBelt.vc.d.ts

@@ -0,0 +1,29 @@
+import { AbstractViewController, SpruceSchemas, StickyTool, StickyToolPosition, ViewControllerOptions } from '..';
+type ViewModel = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBelt;
+type Tool = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBeltTool;
+export type ToolBeltViewControllerOptions = Partial<ViewModel>;
+export interface OpenToolBeltOptions {
+    shouldStayOpen?: boolean;
+}
+export default class ToolBeltViewController extends AbstractViewController<ViewModel> {
+    private model;
+    private handleFocusTool;
+    private stickyTools;
+    constructor(options: ToolBeltViewControllerOptions & ViewControllerOptions);
+    addTool(tool: Tool): void;
+    setStickyTool(sticky: StickyTool): void;
+    getStickyTools(): Record<StickyToolPosition, SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBeltTool | undefined>;
+    clearStickyTools(): void;
+    setTools(tools: SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBeltTool[]): void;
+    removeTool(id: string): void;
+    removeStickyTool(position: StickyToolPosition): void;
+    getTools(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBeltTool[];
+    clearTools(): void;
+    getTool(id: string): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBeltTool | undefined;
+    focusTool(id: string): void;
+    renderTools(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBeltTool[];
+    close(): void;
+    open(options?: OpenToolBeltOptions): void;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBelt;
+}
+export {};