@sprucelabs/spruce-cli 19.0.0 → 19.1.0

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

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+class AbstractViewController {
+    constructor(options) {
+        this.wasDestroyed = false;
+        this.children = [];
+        this.vcFactory = options.vcFactory;
+        this.renderInDialogHandler = options.renderInDialogHandler;
+        this.confirmHandler = options.confirmHandler;
+        this.connectToApi = options.connectToApi;
+        this.voteHandler = options.voteHandler;
+        this.device = options.device;
+        this.dates = options.dates;
+        this.maps = options.maps;
+    }
+    triggerRender() { }
+    getVcFactory() {
+        return this.vcFactory;
+    }
+    mixinControllers(map) {
+        this.vcFactory.mixinControllers(map);
+    }
+    Controller(name, options) {
+        const vc = this.vcFactory.Controller(name, options);
+        if (vc) {
+            //@ts-ignore
+            vc.getParent = () => this;
+        }
+        this.children.push(vc);
+        return vc;
+    }
+    renderInDialog(dialog) {
+        const controller = this.Controller('dialog', Object.assign(Object.assign({}, dialog), { isVisible: true }));
+        this.renderInDialogHandler(controller.render());
+        this.activeDialog = controller;
+        return controller;
+    }
+    async hideDialog() {
+        var _a;
+        await ((_a = this.activeDialog) === null || _a === void 0 ? void 0 : _a.hide());
+    }
+    async askForAVote(options) {
+        await this.voteHandler(options);
+    }
+    suspendRendering() {
+        this._suspendedRender = this.triggerRender.bind(this);
+        this.triggerRender = () => { };
+    }
+    restoreRendering() {
+        if (this._suspendedRender) {
+            this.triggerRender = this._suspendedRender;
+        }
+    }
+    async renderOnce(cb) {
+        this.suspendRendering();
+        await cb();
+        this.restoreRendering();
+        this.triggerRender();
+    }
+    async destroy() {
+        if (this.wasDestroyed) {
+            //@ts-ignore
+            throw new SpruceError_1.default({ code: 'VIEW_ALREADY_DESTROYED', viewId: this.id });
+        }
+        await Promise.all(this.children.map((c) => { var _a; return (_a = c.destroy) === null || _a === void 0 ? void 0 : _a.call(c); }));
+        this.wasDestroyed = true;
+    }
+    async alert(options) {
+        const { title = 'Alert! 🌲🤖' } = options;
+        const header = {
+            title,
+        };
+        const dlg = this.renderInDialog({
+            header,
+            body: {
+                sections: [
+                    {
+                        text: {
+                            content: options.message,
+                        },
+                    },
+                ],
+            },
+            footer: {
+                buttons: [
+                    {
+                        label: 'Ok',
+                        type: this.styleToButtonType(options.style),
+                        onClick: () => {
+                            void dlg.hide();
+                        },
+                    },
+                ],
+            },
+        });
+        this.device.vibrate();
+        await dlg.wait();
+    }
+    styleToButtonType(style) {
+        switch (style) {
+            case 'error':
+            case undefined:
+                return 'destructive';
+            case 'success':
+                return 'primary';
+            default:
+                return 'secondary';
+        }
+    }
+    async confirm(options) {
+        return this.confirmHandler(options);
+    }
+    async waitForRender() {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    getDevice() {
+        return this.device;
+    }
+}
+exports.default = AbstractViewController;

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

@@ -0,0 +1,26 @@
+import { SpruceSchemas } from "./../.spruce/schemas/schemas.types";
+import { CalendarEventViewController as CalendarEventVc } from '../types/calendar.types';
+import { ViewControllerOptions } from '../types/heartwood.types';
+import AbstractViewController from './Abstract.vc';
+type Event = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+type GetEventHandler = () => Event;
+type SetEventHandler = (event: Event) => void;
+type HasEventHandler = () => boolean;
+export interface CalendarEventOptions extends Event {
+    getEvent: GetEventHandler;
+    setEvent: SetEventHandler;
+    hasEvent: HasEventHandler;
+}
+export default abstract class AbstractCalendarEventViewController extends AbstractViewController<Event> implements CalendarEventVc {
+    static id: string;
+    private setEvent;
+    private getEvent;
+    private hasEvent;
+    constructor(options: ViewControllerOptions & CalendarEventOptions);
+    setIsBusy(isBusy: boolean): void;
+    getIsBusy(): boolean;
+    getIsOrphaned(): boolean;
+    mixinChanges(changes: Partial<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent>): void;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+}
+export {};

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

@@ -0,0 +1,34 @@
+"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 AbstractCalendarEventViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        super(options);
+        (0, schema_1.assertOptions)(options, ['setEvent', 'getEvent', 'hasEvent']);
+        this.setEvent = options.setEvent;
+        this.getEvent = options.getEvent;
+        this.hasEvent = options.hasEvent;
+    }
+    setIsBusy(isBusy) {
+        this.mixinChanges({ isBusy });
+    }
+    getIsBusy() {
+        var _a;
+        return (_a = this.getEvent().isBusy) !== null && _a !== void 0 ? _a : false;
+    }
+    getIsOrphaned() {
+        return !this.hasEvent();
+    }
+    mixinChanges(changes) {
+        this.setEvent(Object.assign(Object.assign({}, this.getEvent()), changes));
+    }
+    render() {
+        return Object.assign(Object.assign({}, this.getEvent()), { controller: this });
+    }
+}
+exports.default = AbstractCalendarEventViewController;
+AbstractCalendarEventViewController.id = 'calendar-event';

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

@@ -0,0 +1,24 @@
+import { SpruceSchemas } from '@sprucelabs/mercury-types';
+import { Schema } from '@sprucelabs/schema';
+import FormViewController, { FormViewControllerOptions } from './form/Form.vc';
+export default class BigFormViewController<S extends Schema, V extends ViewModel<S> = ViewModel<S>> extends FormViewController<S, V> {
+    isSlideValid(idx: number): boolean;
+    setOnSubmit(cb: V['onSubmit']): void;
+    setOnSubmitSlide(cb: V['onSubmitSlide']): void;
+    getPresentSlide(): number;
+    jumpToSlide(idx: number): Promise<void>;
+    getTotalSlides(): number;
+    replaySlideHeading(idx: number): void;
+    goForward(): Promise<void>;
+    goBack(): Promise<void>;
+    submit(): Promise<void>;
+    private buildOnSubmitOptions;
+    getIsLastSlide(): boolean;
+    private isPresentSlideValid;
+    render(): V;
+}
+type ViewModel<S extends Schema> = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.BigForm<S>;
+export type BigFormViewControllerOptions<S extends Schema> = FormViewControllerOptions<S> & {
+    onSubmitSlide?: ViewModel<S>['onSubmitSlide'];
+};
+export {};

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

@@ -0,0 +1,90 @@
+"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 normalizeFieldNames_utility_1 = __importDefault(require("../utilities/normalizeFieldNames.utility"));
+const Form_vc_1 = __importDefault(require("./form/Form.vc"));
+class BigFormViewController extends Form_vc_1.default {
+    isSlideValid(idx) {
+        const slide = this.model.sections[idx];
+        if (slide) {
+            const fields = normalizeFieldNames_utility_1.default.toNames(slide.fields);
+            return (0, schema_1.areSchemaValuesValid)(this.model.schema, this.model.values, {
+                fields,
+            });
+        }
+        return false;
+    }
+    setOnSubmit(cb) {
+        this.model.onSubmit = cb;
+    }
+    setOnSubmitSlide(cb) {
+        this.model.onSubmitSlide = cb;
+    }
+    getPresentSlide() {
+        var _a;
+        return (_a = this.model.presentSlide) !== null && _a !== void 0 ? _a : 0;
+    }
+    async jumpToSlide(idx) {
+        var _a, _b;
+        this.model.presentSlide = Math.min(this.getTotalSlides() - 1, Math.max(0, idx));
+        this.triggerRender();
+        const firstFieldOfSection = normalizeFieldNames_utility_1.default.toNames((_b = (_a = this.model.sections[idx]) === null || _a === void 0 ? void 0 : _a.fields) !== null && _b !== void 0 ? _b : [])[0];
+        if (firstFieldOfSection) {
+            this.focusInput(firstFieldOfSection);
+        }
+        this.replaySlideHeading(this.getPresentSlide());
+    }
+    getTotalSlides() {
+        return this.model.sections.length;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    replaySlideHeading(idx) { }
+    async goForward() {
+        await this.jumpToSlide(this.getPresentSlide() + 1);
+    }
+    async goBack() {
+        await this.jumpToSlide(this.getPresentSlide() - 1);
+    }
+    async submit() {
+        var _a, _b, _c, _d;
+        const { options, errorsByField } = this.buildOnSubmitOptions();
+        const results = await ((_b = (_a = this.model).onSubmitSlide) === null || _b === void 0 ? void 0 : _b.call(_a, options));
+        if (results === false) {
+            return;
+        }
+        if (this.getIsLastSlide()) {
+            await ((_d = (_c = this.model).onSubmit) === null || _d === void 0 ? void 0 : _d.call(_c, options));
+        }
+        if (this.isPresentSlideValid()) {
+            await this.goForward();
+        }
+        else {
+            this.setErrorsByField(errorsByField);
+        }
+    }
+    buildOnSubmitOptions() {
+        const errorsByField = this.validate();
+        const options = {
+            values: this.getValues(),
+            presentSlide: this.getPresentSlide(),
+            errorsByField,
+            controller: this,
+            isValid: this.isValid(),
+        };
+        return { options, errorsByField };
+    }
+    getIsLastSlide() {
+        return this.getPresentSlide() === this.getTotalSlides() - 1;
+    }
+    isPresentSlideValid() {
+        return this.isSlideValid(this.getPresentSlide());
+    }
+    render() {
+        const view = Object.assign(Object.assign({}, this.model), { onSubmit: this.submit.bind(this) });
+        return view;
+    }
+}
+exports.default = BigFormViewController;

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

@@ -0,0 +1,17 @@
+import { SpruceSchemas } from '@sprucelabs/mercury-types';
+import { ViewControllerOptions } from '../types/heartwood.types';
+import AbstractViewController from './Abstract.vc';
+import ButtonGroupViewController, { ButtonGroupViewControllerOptions } from './ButtonGroup.vc';
+type ButtonBar = ButtonGroupViewControllerOptions;
+export type ButtonBarViewControllerOptions = ButtonBar;
+export default class ButtonBarViewController extends AbstractViewController<ButtonBar> {
+    private buttonGroupVc;
+    constructor(options: ButtonBar & ViewControllerOptions);
+    getButtonGroupVc(): ButtonGroupViewController;
+    getSelectedButtons(): string[];
+    selectButton(id: string): Promise<void>;
+    selectButtons(ids: string[]): Promise<void>;
+    deselectButton(id: string): Promise<void>;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ButtonBar;
+}
+export {};

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

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Abstract_vc_1 = __importDefault(require("./Abstract.vc"));
+class ButtonBarViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        super(options);
+        this.buttonGroupVc = this.Controller('buttonGroup', Object.assign({}, options));
+    }
+    getButtonGroupVc() {
+        return this.buttonGroupVc;
+    }
+    getSelectedButtons() {
+        return this.buttonGroupVc.getSelectedButtons();
+    }
+    async selectButton(id) {
+        await this.buttonGroupVc.selectButton(id);
+    }
+    async selectButtons(ids) {
+        await this.buttonGroupVc.selectButtons(ids);
+    }
+    async deselectButton(id) {
+        await this.buttonGroupVc.deselectButton(id);
+    }
+    render() {
+        return {
+            controller: this,
+            buttons: this.buttonGroupVc.render(),
+        };
+    }
+}
+exports.default = ButtonBarViewController;

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

@@ -0,0 +1,51 @@
+import { SpruceSchemas } from '@sprucelabs/mercury-types';
+import { ViewControllerOptions } from '../types/heartwood.types';
+import AbstractViewController from './Abstract.vc';
+type Button = Omit<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Button, 'onClick' | 'onClickHintIcon'> & {
+    id: string;
+};
+type ViewModel = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Button[];
+export interface ButtonGroupChanges {
+    added: string[];
+    removed: string[];
+}
+export interface ButtonGroupPendingChanges {
+    adding: string[];
+    removing: string[];
+}
+export type SelectionChangeHandler = (selected: string[], changed: ButtonGroupChanges) => void | Promise<void>;
+export type WillChangeSelectionHandler = (selected: string[], changes: ButtonGroupPendingChanges) => void | boolean | Promise<void | boolean>;
+type HintClickHandler = (selected: string) => void;
+export interface ButtonGroupViewControllerOptions {
+    buttons: Button[];
+    onSelectionChange?: SelectionChangeHandler;
+    onWillChangeSelection?: WillChangeSelectionHandler;
+    onClickHintIcon?: HintClickHandler;
+    shouldAllowMultiSelect?: boolean;
+    selected?: string[];
+}
+export default class ButtonGroupViewController extends AbstractViewController<ViewModel> {
+    private buttons;
+    private selectedButtonIds;
+    private selectionChangeHandler?;
+    private shouldAllowMultiSelect;
+    private buttonTriggerRenderHandlers;
+    private buttonControllers;
+    private hasBeenRendered;
+    private clickHintHandler?;
+    private willChangeSelectionHandler?;
+    constructor(options: ButtonGroupViewControllerOptions & ViewControllerOptions);
+    triggerRender(): void;
+    selectButtons(ids: string[]): Promise<void>;
+    selectButton(id: string): Promise<void>;
+    private didSelectHandler;
+    private rebuildAndTriggerRender;
+    private isSelected;
+    deselectButton(id: string): Promise<void>;
+    private rebuildButtons;
+    private buildButtonController;
+    private handleClickHintIcon;
+    getSelectedButtons(): string[];
+    render(): ViewModel;
+}
+export {};

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

@@ -0,0 +1,118 @@
+"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 ButtonGroupViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        this.selectedButtonIds = [];
+        this.buttonTriggerRenderHandlers = [];
+        this.buttonControllers = [];
+        this.hasBeenRendered = [];
+        this.buttons = options.buttons;
+        this.selectionChangeHandler = options.onSelectionChange;
+        this.willChangeSelectionHandler = options.onWillChangeSelection;
+        this.shouldAllowMultiSelect = (_a = options.shouldAllowMultiSelect) !== null && _a !== void 0 ? _a : false;
+        this.clickHintHandler = options.onClickHintIcon;
+        this.selectedButtonIds = (_b = options.selected) !== null && _b !== void 0 ? _b : [];
+        this.rebuildButtons();
+    }
+    triggerRender() {
+        for (const handler of this.buttonTriggerRenderHandlers) {
+            handler();
+        }
+    }
+    async selectButtons(ids) {
+        var _a;
+        let addingIds = ids.filter((id, idx) => ids.indexOf(id) === idx);
+        if (!this.shouldAllowMultiSelect && ids[0]) {
+            addingIds = [addingIds[addingIds.length - 1]];
+        }
+        const selectedKey = this.selectedButtonIds.join('-');
+        const newKey = addingIds.join('-');
+        if (selectedKey === newKey) {
+            return;
+        }
+        const adding = ids.filter((id) => this.selectedButtonIds.indexOf(id) === -1);
+        const removing = this.selectedButtonIds.filter((id) => addingIds.indexOf(id) === -1);
+        const changes = { added: adding, removed: removing };
+        const pending = {
+            adding,
+            removing,
+        };
+        const results = await ((_a = this.willChangeSelectionHandler) === null || _a === void 0 ? void 0 : _a.call(this, [...this.selectedButtonIds], pending));
+        if (results === false) {
+            return;
+        }
+        this.selectedButtonIds = addingIds;
+        await this.didSelectHandler(changes);
+    }
+    async selectButton(id) {
+        const selected = [...this.selectedButtonIds, id];
+        await this.selectButtons(selected);
+    }
+    async didSelectHandler(changes) {
+        var _a;
+        this.rebuildAndTriggerRender();
+        await ((_a = this.selectionChangeHandler) === null || _a === void 0 ? void 0 : _a.call(this, [...this.selectedButtonIds], changes));
+    }
+    rebuildAndTriggerRender() {
+        this.rebuildButtons();
+        this.triggerRender();
+    }
+    isSelected(id) {
+        if (this.selectedButtonIds.length === 0) {
+            return null;
+        }
+        return this.selectedButtonIds.indexOf(id) > -1;
+    }
+    async deselectButton(id) {
+        const selected = this.selectedButtonIds.filter((i) => i !== id);
+        await this.selectButtons(selected);
+    }
+    rebuildButtons() {
+        this.buttonControllers = this.buttons.map((button, idx) => ({
+            controller: this.buildButtonController(button, idx),
+        }));
+    }
+    buildButtonController(button, idx) {
+        if (!button.id) {
+            (0, schema_1.assertOptions)(button, ['id']);
+        }
+        const controller = {
+            triggerRender: () => { },
+            //@ts-ignore
+            render: () => {
+                this.buttonTriggerRenderHandlers[idx] = controller.triggerRender;
+                this.hasBeenRendered[idx] = true;
+                const options = Object.assign(Object.assign({}, button), { controller, isSelected: this.isSelected(button.id), onClick: () => {
+                        if (!this.isSelected(button.id)) {
+                            return this.selectButton(button.id);
+                        }
+                        else {
+                            return this.deselectButton(button.id);
+                        }
+                    }, onClickHintIcon: () => {
+                        this.handleClickHintIcon(button.id);
+                    } });
+                return options;
+            },
+        };
+        return controller;
+    }
+    handleClickHintIcon(id) {
+        var _a;
+        (_a = this.clickHintHandler) === null || _a === void 0 ? void 0 : _a.call(this, id);
+    }
+    getSelectedButtons() {
+        return this.selectedButtonIds;
+    }
+    render() {
+        return this.buttonControllers;
+    }
+}
+exports.default = ButtonGroupViewController;

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

@@ -0,0 +1,70 @@
+import { SpruceSchemas } from "./../.spruce/schemas/schemas.types";
+import { ViewControllerOptions, CalendarEventViewController } from '../types/heartwood.types';
+import AbstractViewController from './Abstract.vc';
+type CalendarOptions = Omit<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Calendar, 'controller' | 'events'> & {
+    events?: ConstructorEvent[];
+};
+type Time = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarTime;
+type Event = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+type ConstructorEvent = Omit<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent, 'isSelected'>;
+type Person = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarPerson;
+type SelectedDate = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarSelectedDate;
+export type CalendarViewControllerOptions = CalendarOptions;
+export type CalendarView = NonNullable<CalendarOptions['view']>;
+export default class CalendarViewController extends AbstractViewController<CalendarOptions> {
+    protected model: Omit<CalendarOptions, 'events'>;
+    private vcIdsByEventType;
+    private vcsById;
+    private eventsById;
+    private defaultEventVcId?;
+    private selectedEventId?;
+    constructor(options: CalendarOptions & ViewControllerOptions);
+    getPeople(): Person[];
+    setPeople(people: Person[]): void;
+    private assertValidMinAndMaxTime;
+    setMinTime(time: Time): void;
+    setMaxTime(time: Time): void;
+    getIsAnimationEnabled(): boolean;
+    setShifts(shifts: SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarShift[]): void;
+    enableAnimation(): void;
+    disableAnimations(): void;
+    setTimezoneOffsetMs(offsetMs: number): any;
+    getTimezoneOffsetMs(): any;
+    getShifts(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarShift[] | null | undefined;
+    selectEvent(id: string): Promise<void>;
+    deselectEvent(): Promise<void>;
+    private deselectAndOptionallyTriggerRender;
+    deselectDate(year: number, month: number, day: number): void;
+    getSelectedDates(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarSelectedDate[];
+    clearSelectedDates(): void;
+    isDateSelected(year: number, month: number, day: number): boolean;
+    getSelectedEvent(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent | undefined;
+    getView(): "month" | "day" | null | undefined;
+    setView(view: CalendarView): void;
+    addEvent(event: Event): void;
+    private doesEventExist;
+    removeEvent(id: string): Promise<void>;
+    removeEvents(ids: string[]): Promise<void>;
+    clearEvents(): void;
+    removePerson(id: string): void;
+    addPerson(person: Person): void;
+    updateEvent(id: string, updates: Partial<Event>): Event;
+    getEvent(id: string): Event;
+    private findEvent;
+    getDefaultControllerForEvents(): string | undefined;
+    setDefaultControllerForEvents(vcId: string): void;
+    setControllerForEventType(type: string, vcId: string): void;
+    getEventVc(eventId: string): CalendarEventViewController;
+    hasEvent(id: string): boolean;
+    mixinEvents(events: Event[]): void;
+    getEvents(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent[];
+    setStartDate(date: number): Promise<void>;
+    getStartDate(): number | null | undefined;
+    setSelectedDates(dates: SelectedDate[]): void;
+    selectDate(year: number, month: number, day: number): void;
+    replaceEventsInRange(events: Event[], startDate: number, endDate: number): void;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Calendar & {
+        events: Event[];
+    };
+}
+export {};