@sprucelabs/spruce-calendar-components 20.11.1 → 21.0.4

package/build/esm/viewControllers/CalendarSelectTool.vc.js

@@ -0,0 +1,103 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AbstractViewController, buildActiveRecordCard, } from '@sprucelabs/heartwood-view-controllers';
+import { assertOptions } from '@sprucelabs/schema';
+export default class CalendarSelectCardViewController extends AbstractViewController {
+    constructor(options) {
+        super(options);
+        this.isLoaded = false;
+        this.selectedCalendarIds = [];
+        const { events } = assertOptions(options, ['events']);
+        this.events = events;
+        this.selectedCalendarIds = this.events.getVisibleCalendarIds();
+        this.activeVc = this.CalendarListVc();
+    }
+    CalendarListVc() {
+        return this.Controller('activeRecordCard', buildActiveRecordCard({
+            shouldRenderRowDividers: true,
+            columnWidths: ['fill'],
+            header: {
+                title: 'Calendars',
+            },
+            noResultsRow: {
+                cells: [
+                    {
+                        text: { content: "You don't have any calendars yet!" },
+                    },
+                ],
+            },
+            eventName: 'calendar.list-calendars::v2021_05_19',
+            rowTransformer: this.renderCalendarRow.bind(this),
+            responseKey: 'calendars',
+        }));
+    }
+    renderCalendarRow(calendar) {
+        return {
+            id: calendar.id,
+            cells: [
+                {
+                    text: { content: calendar.title },
+                },
+                {
+                    toggleInput: {
+                        name: 'isVisible',
+                        value: this.selectedCalendarIds.indexOf(calendar.id) > -1,
+                        onChange: (isVisible) => __awaiter(this, void 0, void 0, function* () {
+                            this.changePromise = this.events.setCalendarVisibility(calendar.id, isVisible);
+                            return this.changePromise;
+                        }),
+                    },
+                },
+            ],
+        };
+    }
+    waitForChanges() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.changePromise;
+        });
+    }
+    getActiveRecordCardVc() {
+        return this.activeVc;
+    }
+    getListVc() {
+        return this.activeVc.getListVc();
+    }
+    getIsLoaded() {
+        return this.isLoaded;
+    }
+    getSelectedCalendarIds() {
+        const records = this.activeVc.getRecords();
+        const ids = [];
+        for (const calendar of records) {
+            if (this.getListVc().getRowVc(calendar.id).getValue('isVisible')) {
+                ids.push(calendar.id);
+            }
+        }
+        return ids;
+    }
+    load(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions(options, ['scope']);
+            const { scope } = options;
+            const org = yield scope.getCurrentOrganization();
+            if (org) {
+                this.activeVc.setTarget({
+                    organizationId: org === null || org === void 0 ? void 0 : org.id,
+                });
+            }
+            yield this.activeVc.load();
+            this.isLoaded = true;
+        });
+    }
+    render() {
+        return this.activeVc.render();
+    }
+}
+CalendarSelectCardViewController.id = 'calendar-select-tool';

package/build/esm/viewControllers/DateSelectCard.vc.d.ts

@@ -0,0 +1,29 @@
+import { AbstractViewController, CalendarViewController, SpruceSchemas, ViewControllerOptions } from '@sprucelabs/heartwood-view-controllers';
+declare type Card = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+declare type DateSelectHandler = (dateTimeMs: number) => void | Promise<void>;
+export interface DateSelectOptions {
+    onSelectDate: DateSelectHandler;
+    startDate: number;
+    selectedDate?: {
+        year: number;
+        month: number;
+        day: number;
+    };
+}
+export default class DateSelectCardViewController extends AbstractViewController<Card> {
+    static id: string;
+    private cardVc;
+    private calendarVc;
+    private dateSelectHandler;
+    constructor(options: ViewControllerOptions & DateSelectOptions);
+    getStartDate(): number | null | undefined;
+    setStartDate(startDate: number): void;
+    private CalendarVc;
+    private handleDateSelect;
+    private CardVc;
+    setSelectedDate(year: number, month: number, day: number): void;
+    getSelectedDate(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarSelectedDate;
+    getCalendarVc(): CalendarViewController;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+}
+export {};

package/build/esm/viewControllers/DateSelectCard.vc.js

@@ -0,0 +1,77 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { dateUtil } from '@sprucelabs/calendar-utils';
+import { AbstractViewController, } from '@sprucelabs/heartwood-view-controllers';
+import { assertOptions } from '@sprucelabs/schema';
+export default class DateSelectCardViewController extends AbstractViewController {
+    constructor(options) {
+        super(options);
+        const { onSelectDate, startDate, selectedDate } = assertOptions(options, [
+            'onSelectDate',
+            'startDate',
+        ]);
+        this.dateSelectHandler = onSelectDate;
+        this.calendarVc = this.CalendarVc({
+            startDate,
+            selectedDates: selectedDate ? [selectedDate] : [],
+        });
+        this.cardVc = this.CardVc();
+    }
+    getStartDate() {
+        return this.calendarVc.getStartDate();
+    }
+    setStartDate(startDate) {
+        this.calendarVc.setStartDate(startDate);
+    }
+    CalendarVc(options) {
+        return this.Controller('calendar', Object.assign({ view: 'month', onClick: ({ dateTimeMs }) => this.handleDateSelect(dateTimeMs), selectedDates: [] }, options));
+    }
+    handleDateSelect(dateTimeMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { year, month, day } = dateUtil.splitDate(dateTimeMs);
+            yield this.calendarVc.renderOnce(() => {
+                this.calendarVc.setStartDate(dateTimeMs);
+                this.calendarVc.clearSelectedDates();
+                this.calendarVc.selectDate(year, month, day);
+            });
+            yield this.dateSelectHandler(dateTimeMs !== null && dateTimeMs !== void 0 ? dateTimeMs : 0);
+        });
+    }
+    CardVc() {
+        return this.Controller('card', {
+            body: {
+                sections: [
+                    {
+                        calendar: this.calendarVc.render(),
+                    },
+                ],
+            },
+        });
+    }
+    setSelectedDate(year, month, day) {
+        this.calendarVc.setSelectedDates([
+            {
+                year,
+                month,
+                day,
+            },
+        ]);
+    }
+    getSelectedDate() {
+        return this.calendarVc.getSelectedDates()[0];
+    }
+    getCalendarVc() {
+        return this.calendarVc;
+    }
+    render() {
+        return this.cardVc.render();
+    }
+}
+DateSelectCardViewController.id = 'date-select-card';

package/build/esm/viewControllers/PersonSelectTool.vc.d.ts

@@ -0,0 +1,36 @@
+import { AbstractViewController, SpruceSchemas, ViewControllerOptions, ButtonBarViewController, Card, ListViewController } from '@sprucelabs/heartwood-view-controllers';
+import CalendarPeopleManager from '../utilities/CalendarPeopleManager';
+export default class PersonSelectToolViewController extends AbstractViewController<Card> {
+    static id: string;
+    private shouldUpdateVisibilityOnToggleChange;
+    private updatePromise?;
+    private get visiblePeopleIds();
+    private isLoaded;
+    private get loggedInPersonId();
+    private cardVc;
+    private listVc;
+    private modeButtonBarVc;
+    private get mode();
+    private people;
+    constructor(options: ViewControllerOptions & PersonSelectCardOptions);
+    private CardVc;
+    private ModeButtonBarVc;
+    waitForSave(): Promise<void | undefined>;
+    private ListVc;
+    private renderRow;
+    private handleChangeMode;
+    getModeButtonBar(): ButtonBarViewController;
+    load(): Promise<void>;
+    private handlePeopleUpdated;
+    getListVc(): ListViewController;
+    getMode(): PersonMode;
+    setMode(mode: PersonMode): Promise<void>;
+    getIsLoaded(): boolean;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+}
+export declare type PersonVisibilityToggleHandler = (person: SpruceSchemas.Spruce.v2020_07_22.Person, isVisible: boolean) => void;
+export declare type PersonVisibilytModeToggleHandler = (mode: PersonMode) => Promise<void> | void;
+export declare type PersonMode = 'me' | 'custom' | 'working';
+export interface PersonSelectCardOptions {
+    people: CalendarPeopleManager;
+}

package/build/esm/viewControllers/PersonSelectTool.vc.js

@@ -0,0 +1,156 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AbstractViewController, } from '@sprucelabs/heartwood-view-controllers';
+import { assertOptions } from '@sprucelabs/schema';
+export default class PersonSelectToolViewController extends AbstractViewController {
+    constructor(options) {
+        super(options);
+        this.shouldUpdateVisibilityOnToggleChange = true;
+        this.isLoaded = false;
+        const { people } = assertOptions(options, ['people']);
+        this.people = people;
+        this.listVc = this.ListVc();
+        this.modeButtonBarVc = this.ModeButtonBarVc();
+        this.cardVc = this.CardVc();
+    }
+    get visiblePeopleIds() {
+        return this.people.getVisiblePeople().map((p) => p.id);
+    }
+    get loggedInPersonId() {
+        var _a;
+        return (_a = this.people.getLoggedInPerson()) === null || _a === void 0 ? void 0 : _a.id;
+    }
+    get mode() {
+        return this.people.getVisibilityMode();
+    }
+    CardVc() {
+        return this.Controller('card', {
+            header: {
+                title: 'People',
+            },
+            body: {
+                sections: [
+                    {
+                        buttonBar: this.modeButtonBarVc.render(),
+                    },
+                    {
+                        list: this.listVc.render(),
+                        shouldBePadded: false,
+                    },
+                ],
+            },
+        });
+    }
+    ModeButtonBarVc() {
+        return this.Controller('buttonBar', {
+            selected: [this.mode],
+            onSelectionChange: this.handleChangeMode.bind(this),
+            buttons: [
+                {
+                    id: 'custom',
+                    label: 'Custom',
+                    lineIcon: 'users',
+                },
+                {
+                    id: 'working',
+                    label: 'Working',
+                    lineIcon: 'clipboard',
+                },
+                {
+                    id: 'me',
+                    label: 'Me',
+                    lineIcon: 'user',
+                },
+            ],
+        });
+    }
+    waitForSave() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.updatePromise;
+        });
+    }
+    ListVc() {
+        return this.Controller('list', {
+            columnWidths: ['fill'],
+            rows: this.people.getTeam().map((p) => this.renderRow(p)),
+        });
+    }
+    renderRow(person) {
+        return {
+            id: person.id,
+            cells: [
+                {
+                    text: {
+                        content: person.id === this.loggedInPersonId ? 'You' : person.casualName,
+                    },
+                },
+                {
+                    toggleInput: {
+                        name: 'isVisible',
+                        value: !!this.visiblePeopleIds.find((id) => id === person.id),
+                        onChange: (value) => __awaiter(this, void 0, void 0, function* () {
+                            if (this.shouldUpdateVisibilityOnToggleChange) {
+                                this.updatePromise = this.people.setPersonVisibility(person.id, value !== null && value !== void 0 ? value : false);
+                            }
+                        }),
+                    },
+                },
+            ],
+        };
+    }
+    handleChangeMode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.people.setVisibilityMode(this.getMode());
+        });
+    }
+    getModeButtonBar() {
+        return this.modeButtonBarVc;
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isLoaded = true;
+            yield this.people.on('did-update', this.handlePeopleUpdated.bind(this));
+        });
+    }
+    handlePeopleUpdated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.getMode() !== this.people.getVisibilityMode()) {
+                yield this.setMode(this.people.getVisibilityMode());
+            }
+            const rows = this.listVc.getRowVcs();
+            const visiblePeople = this.people.getVisiblePeople().map((p) => p.id);
+            this.shouldUpdateVisibilityOnToggleChange = false;
+            yield Promise.all(rows.map((row) => __awaiter(this, void 0, void 0, function* () {
+                const shouldBeSelected = visiblePeople.indexOf(row.getId()) > -1;
+                yield row.setValue('isVisible', shouldBeSelected);
+            })));
+            this.shouldUpdateVisibilityOnToggleChange = true;
+        });
+    }
+    getListVc() {
+        return this.listVc;
+    }
+    getMode() {
+        const [mode] = this.modeButtonBarVc.getSelectedButtons();
+        return mode;
+    }
+    setMode(mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.modeButtonBarVc.selectButtons([mode]);
+        });
+    }
+    getIsLoaded() {
+        return this.isLoaded;
+    }
+    render() {
+        return this.cardVc.render();
+    }
+}
+PersonSelectToolViewController.id = 'person-select-tool';

package/build/esm/viewControllers/SelectUpdateRepeatingStrategyCard.vc.d.ts

@@ -0,0 +1,18 @@
+import { AbstractViewController, SpruceSchemas, ViewControllerOptions } from '@sprucelabs/heartwood-view-controllers';
+import { CalendarEvent, UpdateRepeatingStrategyWithCancel } from '../types/calendar.types';
+export default class SelectUpdateRepeatingStrategyCardViewController extends AbstractViewController<Card> {
+    static id: string;
+    private cardVc;
+    private event;
+    private onSelectStrategy;
+    constructor(options: ViewControllerOptions & SelectUpdateRepeatingStrategyOptions);
+    private CardVc;
+    getEvent(): CalendarEvent;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+}
+declare type Card = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+export interface SelectUpdateRepeatingStrategyOptions {
+    event: CalendarEvent;
+    onSelectStrategy: (strategy: UpdateRepeatingStrategyWithCancel) => Promise<void> | void;
+}
+export {};

package/build/esm/viewControllers/SelectUpdateRepeatingStrategyCard.vc.js

@@ -0,0 +1,85 @@
+import { AbstractViewController, } from '@sprucelabs/heartwood-view-controllers';
+import { assertOptions } from '@sprucelabs/schema';
+import { randomUtil } from '@sprucelabs/spruce-skill-utils';
+export default class SelectUpdateRepeatingStrategyCardViewController extends AbstractViewController {
+    constructor(options) {
+        super(options);
+        assertOptions(options, ['event', 'onSelectStrategy']);
+        this.onSelectStrategy = options.onSelectStrategy;
+        this.event = options.event;
+        this.cardVc = this.CardVc();
+    }
+    CardVc() {
+        var _a;
+        const buttons = [
+            {
+                id: 'only-this-one',
+                label: 'Update only this event',
+            },
+        ];
+        if (((_a = this.event.nthInRepeating) !== null && _a !== void 0 ? _a : 0) > 0) {
+            buttons.push({
+                id: 'all-going-forward',
+                label: 'Update this and all going forward',
+            });
+        }
+        buttons.push({
+            id: 'all',
+            label: 'Update all events',
+        });
+        buttons.forEach((button) => {
+            button.onClick = () => this.onSelectStrategy(button.id);
+        });
+        return this.Controller('card', {
+            header: {
+                title: `How do you want to update?`,
+                subtitle: `This is the ${this.event.nthInRepeating
+                    ? ordinal_suffix_of(this.event.nthInRepeating)
+                    : 'first'} of ${this.event.activeUntilDate
+                    ? this.event.totalInRepeating
+                    : randomUtil.rand([
+                        'as far as the eye can see!',
+                        'pretty much forever!',
+                        'unlimited events.',
+                        'eternity!',
+                    ])}`,
+            },
+            body: {
+                sections: [
+                    {
+                        buttons,
+                    },
+                ],
+            },
+            footer: {
+                buttons: [
+                    {
+                        id: 'cancel',
+                        label: 'Cancel',
+                        onClick: () => this.onSelectStrategy('cancel'),
+                    },
+                ],
+            },
+        });
+    }
+    getEvent() {
+        return this.event;
+    }
+    render() {
+        return this.cardVc.render();
+    }
+}
+SelectUpdateRepeatingStrategyCardViewController.id = 'select-update-repeating-strategy-card';
+function ordinal_suffix_of(i) {
+    let j = i % 10, k = i % 100;
+    if (j == 1 && k != 11) {
+        return i + 'st';
+    }
+    if (j == 2 && k != 12) {
+        return i + 'nd';
+    }
+    if (j == 3 && k != 13) {
+        return i + 'rd';
+    }
+    return i + 'th';
+}

package/build/index-module.d.ts

@@ -0,0 +1,30 @@
+export { default as calendarAssert } from './__tests__/support/utilities/calendarAssert';
+export { default as calendarSkillAssert } from './__tests__/support/utilities/calendarSkillAssert';
+export { default as CalendarToolBeltStateMachineTestFactory } from './__tests__/support/CalendarToolBeltStateMachineTestFactory';
+export { default as CalendarToolTestFactory } from './toolBelt/CalendarToolTestFactory';
+export * from './toolBelt/CalendarToolTestFactory';
+export { default as calendarToolBeltInteractor } from './__tests__/support/utilities/calendarToolBeltInteractor';
+import CalendarViewController from './viewControllers/Calendar.vc';
+import EventControlsCardViewController from './viewControllers/EventControlsCard.vc';
+import EventDateTimeToolViewController from './viewControllers/EventDateTimeTool.vc';
+import EventRepeatingToolViewController from './viewControllers/EventRepeatingTool.vc';
+import EventTitleToolViewController from './viewControllers/EventTitleTool.vc';
+import RepeatingControlsListViewController from './viewControllers/RepeatingControlsList.vc';
+export * from './index-components';
+declare module '@sprucelabs/heartwood-view-controllers/build/types/heartwood.types' {
+    interface ViewControllerMap {
+        'calendar.repeating-controls-list': RepeatingControlsListViewController;
+        'calendar.calendar': CalendarViewController;
+        'calendar.event-date-time-tool': EventDateTimeToolViewController;
+        'calendar.event-repeating-tool': EventRepeatingToolViewController;
+        'calendar.event-title-tool': EventTitleToolViewController;
+        'calendar.event-controls-card': EventControlsCardViewController;
+    }
+    interface ViewControllerOptionsMap {
+        'calendar.repeating-controls-list': ConstructorParameters<typeof RepeatingControlsListViewController>[0];
+        'calendar.calendar': ConstructorParameters<typeof CalendarViewController>[0];
+        'calendar.event-date-time-tool': ConstructorParameters<typeof EventDateTimeToolViewController>[0];
+        'calendar.event-repeating-tool': ConstructorParameters<typeof EventRepeatingToolViewController>[0];
+        'calendar.event-title-tool': ConstructorParameters<typeof EventTitleToolViewController>[0];
+    }
+}

package/build/index-module.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calendarToolBeltInteractor = exports.CalendarToolTestFactory = exports.CalendarToolBeltStateMachineTestFactory = exports.calendarSkillAssert = exports.calendarAssert = void 0;
+var calendarAssert_1 = require("./__tests__/support/utilities/calendarAssert");
+Object.defineProperty(exports, "calendarAssert", { enumerable: true, get: function () { return __importDefault(calendarAssert_1).default; } });
+var calendarSkillAssert_1 = require("./__tests__/support/utilities/calendarSkillAssert");
+Object.defineProperty(exports, "calendarSkillAssert", { enumerable: true, get: function () { return __importDefault(calendarSkillAssert_1).default; } });
+var CalendarToolBeltStateMachineTestFactory_1 = require("./__tests__/support/CalendarToolBeltStateMachineTestFactory");
+Object.defineProperty(exports, "CalendarToolBeltStateMachineTestFactory", { enumerable: true, get: function () { return __importDefault(CalendarToolBeltStateMachineTestFactory_1).default; } });
+var CalendarToolTestFactory_1 = require("./toolBelt/CalendarToolTestFactory");
+Object.defineProperty(exports, "CalendarToolTestFactory", { enumerable: true, get: function () { return __importDefault(CalendarToolTestFactory_1).default; } });
+__exportStar(require("./toolBelt/CalendarToolTestFactory"), exports);
+var calendarToolBeltInteractor_1 = require("./__tests__/support/utilities/calendarToolBeltInteractor");
+Object.defineProperty(exports, "calendarToolBeltInteractor", { enumerable: true, get: function () { return __importDefault(calendarToolBeltInteractor_1).default; } });
+__exportStar(require("./index-components"), exports);

package/build/skillViewControllers/Root.svc.d.ts

@@ -0,0 +1,73 @@
+import { AbstractSkillViewController, SkillViewControllerLoadOptions, SpruceSchemas, ViewControllerOptions, ScopeFlag } from '@sprucelabs/heartwood-view-controllers';
+import { RemoteViewControllerFactory } from '@sprucelabs/spruce-heartwood-utils';
+import RemotePreferencesStore from '../stores/RemotePreferencesStore';
+import { CalendarToolBeltStateMachine } from '../types/calendar.types';
+import { CalendarEventManager } from '../utilities/CalendarEventManager';
+import CalendarPeopleManager from '../utilities/CalendarPeopleManager';
+import CalendarViewController from '../viewControllers/Calendar.vc';
+export default class RootSkillViewController extends AbstractSkillViewController<Args> {
+    static id: string;
+    private calendarVc;
+    private toolBeltVc;
+    private person?;
+    private sm;
+    private toolBeltStates;
+    private remoteEventStore;
+    private selectingTypePromise?;
+    private selectingTypeResolve?;
+    private client;
+    private organizationId;
+    private locationId;
+    private transitionPromise?;
+    private loadEventsPromise?;
+    protected events: CalendarEventManager;
+    protected preferences: RemotePreferencesStore;
+    protected people: CalendarPeopleManager;
+    protected remoteVc: RemoteViewControllerFactory;
+    constructor(options: ViewControllerOptions);
+    getScope: () => ScopeFlag[];
+    private createToolBeltStates;
+    private ToolBeltStateMachine;
+    private handleCancelEvent;
+    private askForUpdateStrategy;
+    private handleSelectEventType;
+    private restoreDraftAfterStateLoadError;
+    private transitionToStateFromDraftEvent;
+    private transitionToolBeltForEvent;
+    private transitionTo;
+    waitUntilDoneSaving(): Promise<void>;
+    private handleSelectCalendar;
+    getToolBeltStateMachine(): CalendarToolBeltStateMachine<import("../types/calendar.types").CalendarToolBeltContext>;
+    getToolBeltStateId(): string | undefined;
+    private CalendarVc;
+    private handleChangeDate;
+    private makeDateSelectMatchSelectedDateFromCalendar;
+    private setSelectedDateInDateSelectVc;
+    private getStartDate;
+    private handleDeselectEvent;
+    private resetToRootState;
+    private ToolBeltVc;
+    private handleClickEvent;
+    private handleDraftEventAdded;
+    private handleEventSwapped;
+    private handleDropEvent;
+    private handleDraftEventRemoved;
+    getPersonSelectVc(): import("../viewControllers/PersonSelectTool.vc").default;
+    renderToolBelt(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBelt;
+    getCalendarSelectVc(): import("../viewControllers/CalendarSelectTool.vc").default | undefined;
+    getCalendarVc(): CalendarViewController;
+    load(options: SkillViewControllerLoadOptions<Args>): Promise<void>;
+    private syncPeopleOnCalendar;
+    private syncOffsetWithLocale;
+    private loadEvents;
+    private _loadEvents;
+    protected transitionToRoot(): Promise<void>;
+    private loadLoggedInPerson;
+    private getVisibleEvents;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.SkillView;
+}
+export declare type CalendarPerson = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarPerson;
+interface Args {
+    startDate?: number;
+}
+export {};