@sprucelabs/spruce-calendar-components 21.0.3 → 21.0.4

package/build/.spruce/errors/errors.types.d.ts

@@ -0,0 +1,122 @@
+import { default as SchemaEntity } from '@sprucelabs/schema';
+import * as SpruceSchema from '@sprucelabs/schema';
+export declare namespace SpruceErrors.Calendar {
+    interface ValidatorNotInitialized {
+    }
+    interface ValidatorNotInitializedSchema extends SpruceSchema.Schema {
+        id: 'validatorNotInitialized';
+        namespace: 'Calendar';
+        name: 'validator not initialized';
+        fields: {};
+    }
+    type ValidatorNotInitializedEntity = SchemaEntity<SpruceErrors.Calendar.ValidatorNotInitializedSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface UnauthorizedAccess {
+    }
+    interface UnauthorizedAccessSchema extends SpruceSchema.Schema {
+        id: 'unauthorizedAccess';
+        namespace: 'Calendar';
+        name: 'Unauthorized access';
+        fields: {};
+    }
+    type UnauthorizedAccessEntity = SchemaEntity<SpruceErrors.Calendar.UnauthorizedAccessSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface RecordNotFound {
+        'parameters': string[];
+    }
+    interface RecordNotFoundSchema extends SpruceSchema.Schema {
+        id: 'recordNotFound';
+        namespace: 'Calendar';
+        name: 'record not found';
+        fields: {
+            /** . */
+            'parameters': {
+                type: 'text';
+                isRequired: true;
+                isArray: true;
+                options: undefined;
+            };
+        };
+    }
+    type RecordNotFoundEntity = SchemaEntity<SpruceErrors.Calendar.RecordNotFoundSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface PersonNotFound {
+        'personId': string;
+    }
+    interface PersonNotFoundSchema extends SpruceSchema.Schema {
+        id: 'personNotFound';
+        namespace: 'Calendar';
+        name: 'Person not found';
+        fields: {
+            /** . */
+            'personId': {
+                type: 'id';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type PersonNotFoundEntity = SchemaEntity<SpruceErrors.Calendar.PersonNotFoundSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface EventNotFound {
+    }
+    interface EventNotFoundSchema extends SpruceSchema.Schema {
+        id: 'eventNotFound';
+        namespace: 'Calendar';
+        name: 'Event Not Found';
+        fields: {};
+    }
+    type EventNotFoundEntity = SchemaEntity<SpruceErrors.Calendar.EventNotFoundSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface DuplicateEventType {
+    }
+    interface DuplicateEventTypeSchema extends SpruceSchema.Schema {
+        id: 'duplicateEventType';
+        namespace: 'Calendar';
+        name: 'Duplicate event type';
+        fields: {};
+    }
+    type DuplicateEventTypeEntity = SchemaEntity<SpruceErrors.Calendar.DuplicateEventTypeSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface DuplicateCalendar {
+    }
+    interface DuplicateCalendarSchema extends SpruceSchema.Schema {
+        id: 'duplicateCalendar';
+        namespace: 'Calendar';
+        name: 'Duplicate Calendar';
+        fields: {};
+    }
+    type DuplicateCalendarEntity = SchemaEntity<SpruceErrors.Calendar.DuplicateCalendarSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface CalendarNotFound {
+        'calendarIds'?: string[] | undefined | null;
+        'calendarSlugs'?: string[] | undefined | null;
+    }
+    interface CalendarNotFoundSchema extends SpruceSchema.Schema {
+        id: 'calendarNotFound';
+        namespace: 'Calendar';
+        name: 'calendar not found';
+        fields: {
+            /** . */
+            'calendarIds': {
+                type: 'text';
+                isArray: true;
+                options: undefined;
+            };
+            /** . */
+            'calendarSlugs': {
+                type: 'text';
+                isArray: true;
+                options: undefined;
+            };
+        };
+    }
+    type CalendarNotFoundEntity = SchemaEntity<SpruceErrors.Calendar.CalendarNotFoundSchema>;
+}

package/build/.spruce/errors/errors.types.js

@@ -0,0 +1,4 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-redeclare */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/.spruce/errors/options.types.d.ts

@@ -0,0 +1,28 @@
+import { SpruceErrors } from "./errors.types";
+import { ErrorOptions as ISpruceErrorOptions } from "@sprucelabs/error";
+export interface ValidatorNotInitializedErrorOptions extends SpruceErrors.Calendar.ValidatorNotInitialized, ISpruceErrorOptions {
+    code: 'VALIDATOR_NOT_INITIALIZED';
+}
+export interface UnauthorizedAccessErrorOptions extends SpruceErrors.Calendar.UnauthorizedAccess, ISpruceErrorOptions {
+    code: 'UNAUTHORIZED_ACCESS';
+}
+export interface RecordNotFoundErrorOptions extends SpruceErrors.Calendar.RecordNotFound, ISpruceErrorOptions {
+    code: 'RECORD_NOT_FOUND';
+}
+export interface PersonNotFoundErrorOptions extends SpruceErrors.Calendar.PersonNotFound, ISpruceErrorOptions {
+    code: 'PERSON_NOT_FOUND';
+}
+export interface EventNotFoundErrorOptions extends SpruceErrors.Calendar.EventNotFound, ISpruceErrorOptions {
+    code: 'EVENT_NOT_FOUND';
+}
+export interface DuplicateEventTypeErrorOptions extends SpruceErrors.Calendar.DuplicateEventType, ISpruceErrorOptions {
+    code: 'DUPLICATE_EVENT_TYPE';
+}
+export interface DuplicateCalendarErrorOptions extends SpruceErrors.Calendar.DuplicateCalendar, ISpruceErrorOptions {
+    code: 'DUPLICATE_CALENDAR';
+}
+export interface CalendarNotFoundErrorOptions extends SpruceErrors.Calendar.CalendarNotFound, ISpruceErrorOptions {
+    code: 'CALENDAR_NOT_FOUND';
+}
+declare type ErrorOptions = ValidatorNotInitializedErrorOptions | UnauthorizedAccessErrorOptions | RecordNotFoundErrorOptions | PersonNotFoundErrorOptions | EventNotFoundErrorOptions | DuplicateEventTypeErrorOptions | DuplicateCalendarErrorOptions | CalendarNotFoundErrorOptions;
+export default ErrorOptions;

package/build/.spruce/errors/options.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_GET_SCHEDULE_DAYS: number;
+export declare const UPDATE_STRATEGY_SPECIFIC_DATES: "only-this-one";
+export declare const UPDATE_STRATEGY_THIS_AND_ALL_GOING_FORWARD: "all-going-forward";
+export declare const UPDATE_STRATEGY_ALL: "all";
+export declare type UpdateRepeatingStrategy = typeof UPDATE_STRATEGY_SPECIFIC_DATES | typeof UPDATE_STRATEGY_THIS_AND_ALL_GOING_FORWARD | typeof UPDATE_STRATEGY_ALL;

package/build/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPDATE_STRATEGY_ALL = exports.UPDATE_STRATEGY_THIS_AND_ALL_GOING_FORWARD = exports.UPDATE_STRATEGY_SPECIFIC_DATES = exports.MAX_GET_SCHEDULE_DAYS = void 0;
+require('dotenv').config();
+exports.MAX_GET_SCHEDULE_DAYS = parseInt((_a = process.env.MAX_GETSCHEDULE_DAYS) !== null && _a !== void 0 ? _a : '365');
+exports.UPDATE_STRATEGY_SPECIFIC_DATES = 'only-this-one';
+exports.UPDATE_STRATEGY_THIS_AND_ALL_GOING_FORWARD = 'all-going-forward';
+exports.UPDATE_STRATEGY_ALL = 'all';

package/build/errors/SpruceError.d.ts

@@ -0,0 +1,5 @@
+import AbstractSpruceError from '@sprucelabs/error';
+import ErrorOptions from "./../.spruce/errors/options.types";
+export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
+    friendlyMessage(): string;
+}

package/build/errors/SpruceError.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("@sprucelabs/error"));
+class SpruceError extends error_1.default {
+    friendlyMessage() {
+        const { options } = this;
+        let message;
+        switch (options === null || options === void 0 ? void 0 : options.code) {
+            case 'CALENDAR_NOT_FOUND':
+                message = 'I could not find that calendar!';
+                break;
+            case 'EVENT_NOT_FOUND':
+                message = 'I could not find that event!';
+                break;
+            case 'UNAUTHORIZED_ACCESS':
+                message = 'A Unauthorized access just happened!';
+                break;
+            case 'VALIDATOR_NOT_INITIALIZED':
+                message = 'A validator not initialized just happened!';
+                break;
+            case 'RECORD_NOT_FOUND':
+                message = 'A record not found just happened!';
+                break;
+            case 'DUPLICATE_EVENT_TYPE':
+                message = 'A Duplicate event type just happened!';
+                break;
+            case 'DUPLICATE_CALENDAR':
+                message = 'A Duplicate Calendar just happened!';
+                break;
+            case 'PERSON_NOT_FOUND':
+                message = `I could not find that person!!`;
+                break;
+            default:
+                message = super.friendlyMessage();
+        }
+        const fullMessage = options.friendlyMessage
+            ? options.friendlyMessage
+            : message;
+        return fullMessage;
+    }
+}
+exports.default = SpruceError;

package/build/esm/.spruce/errors/errors.types.d.ts

@@ -0,0 +1,122 @@
+import { default as SchemaEntity } from '@sprucelabs/schema';
+import * as SpruceSchema from '@sprucelabs/schema';
+export declare namespace SpruceErrors.Calendar {
+    interface ValidatorNotInitialized {
+    }
+    interface ValidatorNotInitializedSchema extends SpruceSchema.Schema {
+        id: 'validatorNotInitialized';
+        namespace: 'Calendar';
+        name: 'validator not initialized';
+        fields: {};
+    }
+    type ValidatorNotInitializedEntity = SchemaEntity<SpruceErrors.Calendar.ValidatorNotInitializedSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface UnauthorizedAccess {
+    }
+    interface UnauthorizedAccessSchema extends SpruceSchema.Schema {
+        id: 'unauthorizedAccess';
+        namespace: 'Calendar';
+        name: 'Unauthorized access';
+        fields: {};
+    }
+    type UnauthorizedAccessEntity = SchemaEntity<SpruceErrors.Calendar.UnauthorizedAccessSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface RecordNotFound {
+        'parameters': string[];
+    }
+    interface RecordNotFoundSchema extends SpruceSchema.Schema {
+        id: 'recordNotFound';
+        namespace: 'Calendar';
+        name: 'record not found';
+        fields: {
+            /** . */
+            'parameters': {
+                type: 'text';
+                isRequired: true;
+                isArray: true;
+                options: undefined;
+            };
+        };
+    }
+    type RecordNotFoundEntity = SchemaEntity<SpruceErrors.Calendar.RecordNotFoundSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface PersonNotFound {
+        'personId': string;
+    }
+    interface PersonNotFoundSchema extends SpruceSchema.Schema {
+        id: 'personNotFound';
+        namespace: 'Calendar';
+        name: 'Person not found';
+        fields: {
+            /** . */
+            'personId': {
+                type: 'id';
+                isRequired: true;
+                options: undefined;
+            };
+        };
+    }
+    type PersonNotFoundEntity = SchemaEntity<SpruceErrors.Calendar.PersonNotFoundSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface EventNotFound {
+    }
+    interface EventNotFoundSchema extends SpruceSchema.Schema {
+        id: 'eventNotFound';
+        namespace: 'Calendar';
+        name: 'Event Not Found';
+        fields: {};
+    }
+    type EventNotFoundEntity = SchemaEntity<SpruceErrors.Calendar.EventNotFoundSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface DuplicateEventType {
+    }
+    interface DuplicateEventTypeSchema extends SpruceSchema.Schema {
+        id: 'duplicateEventType';
+        namespace: 'Calendar';
+        name: 'Duplicate event type';
+        fields: {};
+    }
+    type DuplicateEventTypeEntity = SchemaEntity<SpruceErrors.Calendar.DuplicateEventTypeSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface DuplicateCalendar {
+    }
+    interface DuplicateCalendarSchema extends SpruceSchema.Schema {
+        id: 'duplicateCalendar';
+        namespace: 'Calendar';
+        name: 'Duplicate Calendar';
+        fields: {};
+    }
+    type DuplicateCalendarEntity = SchemaEntity<SpruceErrors.Calendar.DuplicateCalendarSchema>;
+}
+export declare namespace SpruceErrors.Calendar {
+    interface CalendarNotFound {
+        'calendarIds'?: string[] | undefined | null;
+        'calendarSlugs'?: string[] | undefined | null;
+    }
+    interface CalendarNotFoundSchema extends SpruceSchema.Schema {
+        id: 'calendarNotFound';
+        namespace: 'Calendar';
+        name: 'calendar not found';
+        fields: {
+            /** . */
+            'calendarIds': {
+                type: 'text';
+                isArray: true;
+                options: undefined;
+            };
+            /** . */
+            'calendarSlugs': {
+                type: 'text';
+                isArray: true;
+                options: undefined;
+            };
+        };
+    }
+    type CalendarNotFoundEntity = SchemaEntity<SpruceErrors.Calendar.CalendarNotFoundSchema>;
+}

package/build/esm/.spruce/errors/errors.types.js

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable no-redeclare */
+export {};

package/build/esm/.spruce/errors/options.types.d.ts

@@ -0,0 +1,28 @@
+import { SpruceErrors } from "./errors.types";
+import { ErrorOptions as ISpruceErrorOptions } from "@sprucelabs/error";
+export interface ValidatorNotInitializedErrorOptions extends SpruceErrors.Calendar.ValidatorNotInitialized, ISpruceErrorOptions {
+    code: 'VALIDATOR_NOT_INITIALIZED';
+}
+export interface UnauthorizedAccessErrorOptions extends SpruceErrors.Calendar.UnauthorizedAccess, ISpruceErrorOptions {
+    code: 'UNAUTHORIZED_ACCESS';
+}
+export interface RecordNotFoundErrorOptions extends SpruceErrors.Calendar.RecordNotFound, ISpruceErrorOptions {
+    code: 'RECORD_NOT_FOUND';
+}
+export interface PersonNotFoundErrorOptions extends SpruceErrors.Calendar.PersonNotFound, ISpruceErrorOptions {
+    code: 'PERSON_NOT_FOUND';
+}
+export interface EventNotFoundErrorOptions extends SpruceErrors.Calendar.EventNotFound, ISpruceErrorOptions {
+    code: 'EVENT_NOT_FOUND';
+}
+export interface DuplicateEventTypeErrorOptions extends SpruceErrors.Calendar.DuplicateEventType, ISpruceErrorOptions {
+    code: 'DUPLICATE_EVENT_TYPE';
+}
+export interface DuplicateCalendarErrorOptions extends SpruceErrors.Calendar.DuplicateCalendar, ISpruceErrorOptions {
+    code: 'DUPLICATE_CALENDAR';
+}
+export interface CalendarNotFoundErrorOptions extends SpruceErrors.Calendar.CalendarNotFound, ISpruceErrorOptions {
+    code: 'CALENDAR_NOT_FOUND';
+}
+declare type ErrorOptions = ValidatorNotInitializedErrorOptions | UnauthorizedAccessErrorOptions | RecordNotFoundErrorOptions | PersonNotFoundErrorOptions | EventNotFoundErrorOptions | DuplicateEventTypeErrorOptions | DuplicateCalendarErrorOptions | CalendarNotFoundErrorOptions;
+export default ErrorOptions;

package/build/esm/.spruce/errors/options.types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_GET_SCHEDULE_DAYS: number;
+export declare const UPDATE_STRATEGY_SPECIFIC_DATES: "only-this-one";
+export declare const UPDATE_STRATEGY_THIS_AND_ALL_GOING_FORWARD: "all-going-forward";
+export declare const UPDATE_STRATEGY_ALL: "all";
+export declare type UpdateRepeatingStrategy = typeof UPDATE_STRATEGY_SPECIFIC_DATES | typeof UPDATE_STRATEGY_THIS_AND_ALL_GOING_FORWARD | typeof UPDATE_STRATEGY_ALL;

package/build/esm/constants.js

@@ -0,0 +1,6 @@
+var _a;
+require('dotenv').config();
+export const MAX_GET_SCHEDULE_DAYS = parseInt((_a = process.env.MAX_GETSCHEDULE_DAYS) !== null && _a !== void 0 ? _a : '365');
+export const UPDATE_STRATEGY_SPECIFIC_DATES = 'only-this-one';
+export const UPDATE_STRATEGY_THIS_AND_ALL_GOING_FORWARD = 'all-going-forward';
+export const UPDATE_STRATEGY_ALL = 'all';

package/build/esm/errors/SpruceError.d.ts

@@ -0,0 +1,5 @@
+import AbstractSpruceError from '@sprucelabs/error';
+import ErrorOptions from "./../.spruce/errors/options.types";
+export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
+    friendlyMessage(): string;
+}

package/build/esm/errors/SpruceError.js

@@ -0,0 +1,39 @@
+import AbstractSpruceError from '@sprucelabs/error';
+export default class SpruceError extends AbstractSpruceError {
+    friendlyMessage() {
+        const { options } = this;
+        let message;
+        switch (options === null || options === void 0 ? void 0 : options.code) {
+            case 'CALENDAR_NOT_FOUND':
+                message = 'I could not find that calendar!';
+                break;
+            case 'EVENT_NOT_FOUND':
+                message = 'I could not find that event!';
+                break;
+            case 'UNAUTHORIZED_ACCESS':
+                message = 'A Unauthorized access just happened!';
+                break;
+            case 'VALIDATOR_NOT_INITIALIZED':
+                message = 'A validator not initialized just happened!';
+                break;
+            case 'RECORD_NOT_FOUND':
+                message = 'A record not found just happened!';
+                break;
+            case 'DUPLICATE_EVENT_TYPE':
+                message = 'A Duplicate event type just happened!';
+                break;
+            case 'DUPLICATE_CALENDAR':
+                message = 'A Duplicate Calendar just happened!';
+                break;
+            case 'PERSON_NOT_FOUND':
+                message = `I could not find that person!!`;
+                break;
+            default:
+                message = super.friendlyMessage();
+        }
+        const fullMessage = options.friendlyMessage
+            ? options.friendlyMessage
+            : message;
+        return fullMessage;
+    }
+}

package/build/esm/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/esm/index-module.js

@@ -0,0 +1,7 @@
+export { default as calendarAssert } from './__tests__/support/utilities/calendarAssert.js';
+export { default as calendarSkillAssert } from './__tests__/support/utilities/calendarSkillAssert.js';
+export { default as CalendarToolBeltStateMachineTestFactory } from './__tests__/support/CalendarToolBeltStateMachineTestFactory.js';
+export { default as CalendarToolTestFactory } from './toolBelt/CalendarToolTestFactory.js';
+export * from './toolBelt/CalendarToolTestFactory.js';
+export { default as calendarToolBeltInteractor } from './__tests__/support/utilities/calendarToolBeltInteractor.js';
+export * from './index-components.js';

package/build/esm/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 {};