@vue-skuilder/common-ui 0.1.14 → 0.1.15

package/dist/components/SnackbarService.d.ts

@@ -1,4 +1,4 @@
-import { Status } from '@vue-skuilder/common';
+import { Status } from '../../../common/dist/index.mjs';
 export interface SnackbarOptions {
     text: string;
     status: Status;

package/dist/components/SnackbarService.vue.d.ts

@@ -0,0 +1,17 @@
+import { SnackbarOptions } from './SnackbarService';
+declare const _default: import('vue').DefineComponent<{}, {}, {
+    /**
+     * A history of snacks served in this session.
+     *
+     * Possible future work: write these to localstorage/pouchdb
+     * for persistance
+     */
+    snacks: SnackbarOptions[];
+    show: boolean[];
+}, {}, {
+    addSnack(snack: SnackbarOptions): void;
+    close(): void;
+    getColor(snack: SnackbarOptions): string | undefined;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=SnackbarService.vue.d.ts.map

package/dist/components/SnackbarService.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SnackbarService.vue.d.ts","sourceRoot":"","sources":["../../src/components/SnackbarService.vue"],"names":[],"mappings":"AAmBA;AAyEA,OAAO,EAAE,eAAe,EAAe,MAAM,mBAAmB,CAAC;;IAO3D;;;;;OAKG;YACW,eAAe,EAAE;UACnB,OAAO,EAAE;;oBASP,eAAe,GAAG,IAAI;aAK7B,IAAI;oBAKG,eAAe,GAAG,MAAM,GAAG,SAAS;;AA/BxD,wBA0CG"}

package/dist/components/StudySession.vue.d.ts

@@ -0,0 +1,378 @@
+import { defineComponent, PropType } from 'vue';
+import { ViewComponent } from '../composables';
+import { default as CardViewer } from './cardRendering/CardViewer.vue';
+import { CourseElo, ViewData } from '../../../common/dist/index.mjs';
+import { CardHistory, CardRecord, ContentSourceID, CourseRegistrationDoc, DataLayerProvider, HydratedCard, ResponseResult, SessionController, StudyContentSource, StudySessionRecord, UserDBInterface } from '../../../db/dist/index.mjs';
+import { StudySessionConfig } from './StudySession.types';
+interface StudyRefs {
+    shadowWrapper: HTMLDivElement;
+    cardViewer: InstanceType<typeof CardViewer>;
+}
+type StudyInstance = ReturnType<typeof defineComponent> & {
+    $refs: StudyRefs;
+};
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    sessionTimeLimit: {
+        type: NumberConstructor;
+        required: true;
+    };
+    contentSources: {
+        type: PropType<ContentSourceID[]>;
+        required: true;
+    };
+    user: {
+        type: PropType<UserDBInterface>;
+        required: true;
+    };
+    dataLayer: {
+        type: PropType<DataLayerProvider>;
+        required: true;
+    };
+    sessionConfig: {
+        type: PropType<StudySessionConfig>;
+        default: () => {
+            likesConfetti: boolean;
+        };
+    };
+    getViewComponent: {
+        type: PropType<(viewId: string) => ViewComponent>;
+        required: true;
+    };
+}>, {}, {
+    cardID: string;
+    view: ViewComponent | null;
+    data: ViewData[];
+    courseID: string;
+    card_elo: number;
+    courseNames: {
+        [courseID: string]: string;
+    };
+    cardCount: number;
+    sessionController: SessionController<ViewComponent> | null;
+    sessionPrepared: boolean;
+    sessionFinished: boolean;
+    sessionRecord: StudySessionRecord[];
+    percentageRemaining: number;
+    timerIsActive: boolean;
+    loading: boolean;
+    userCourseRegDoc: CourseRegistrationDoc | null;
+    sessionContentSources: StudyContentSource[];
+    timeRemaining: number;
+    intervalHandler: NodeJS.Timeout | null;
+    cardType: string;
+    debugMode: boolean;
+}, {
+    currentCard(): StudySessionRecord;
+}, {
+    user_elo(courseID: string): CourseElo;
+    handleClassroomMessage(): (v: unknown) => {};
+    incrementSessionClock(): void;
+    tick(): void;
+    initSession(): Promise<void>;
+    countCardViews(course_id: string, card_id: string): number;
+    processResponse(this: StudyInstance, r: CardRecord): Promise<void>;
+    handleUIFeedback(result: ResponseResult): void;
+    clearFeedbackShadow(): void;
+    logCardRecord(r: CardRecord): Promise<CardHistory<CardRecord>>;
+    loadCard(card: HydratedCard | null): Promise<void>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("session-finished" | "session-started" | "card-loaded" | "card-response" | "time-changed" | "session-prepared" | "session-error")[], "session-finished" | "session-started" | "card-loaded" | "card-response" | "time-changed" | "session-prepared" | "session-error", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    sessionTimeLimit: {
+        type: NumberConstructor;
+        required: true;
+    };
+    contentSources: {
+        type: PropType<ContentSourceID[]>;
+        required: true;
+    };
+    user: {
+        type: PropType<UserDBInterface>;
+        required: true;
+    };
+    dataLayer: {
+        type: PropType<DataLayerProvider>;
+        required: true;
+    };
+    sessionConfig: {
+        type: PropType<StudySessionConfig>;
+        default: () => {
+            likesConfetti: boolean;
+        };
+    };
+    getViewComponent: {
+        type: PropType<(viewId: string) => ViewComponent>;
+        required: true;
+    };
+}>> & Readonly<{
+    "onSession-finished"?: ((...args: any[]) => any) | undefined;
+    "onSession-started"?: ((...args: any[]) => any) | undefined;
+    "onCard-loaded"?: ((...args: any[]) => any) | undefined;
+    "onCard-response"?: ((...args: any[]) => any) | undefined;
+    "onTime-changed"?: ((...args: any[]) => any) | undefined;
+    "onSession-prepared"?: ((...args: any[]) => any) | undefined;
+    "onSession-error"?: ((...args: any[]) => any) | undefined;
+}>, {
+    sessionConfig: StudySessionConfig;
+}, {}, {
+    CardViewer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        sessionOrder: {
+            type: NumberConstructor;
+            required: false;
+            default: number;
+        };
+        card_id: {
+            type: () => PouchDB.Core.DocumentId;
+            required: true;
+            default: string;
+        };
+        course_id: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        view: {
+            type: PropType<ViewComponent>;
+            required: true;
+        };
+        data: {
+            type: () => ViewData[];
+            required: true;
+        };
+        user_elo: {
+            type: () => CourseElo;
+            default: () => {
+                global: {
+                    score: number;
+                    count: number;
+                };
+                tags: {};
+                misc: {};
+            };
+        };
+        card_elo: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>, {}, {}, {}, {
+        processResponse(r: CardRecord): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "emitResponse"[], "emitResponse", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        sessionOrder: {
+            type: NumberConstructor;
+            required: false;
+            default: number;
+        };
+        card_id: {
+            type: () => PouchDB.Core.DocumentId;
+            required: true;
+            default: string;
+        };
+        course_id: {
+            type: StringConstructor;
+            required: true;
+            default: string;
+        };
+        view: {
+            type: PropType<ViewComponent>;
+            required: true;
+        };
+        data: {
+            type: () => ViewData[];
+            required: true;
+        };
+        user_elo: {
+            type: () => CourseElo;
+            default: () => {
+                global: {
+                    score: number;
+                    count: number;
+                };
+                tags: {};
+                misc: {};
+            };
+        };
+        card_elo: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{
+        onEmitResponse?: ((...args: any[]) => any) | undefined;
+    }>, {
+        sessionOrder: number;
+        card_id: string;
+        course_id: string;
+        user_elo: CourseElo;
+        card_elo: number;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    StudySessionTimer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        timeRemaining: {
+            type: NumberConstructor;
+            required: true;
+        };
+        sessionTimeLimit: {
+            type: NumberConstructor;
+            required: true;
+            default: number;
+        };
+    }>, {
+        hovered: import('vue').Ref<boolean, boolean>;
+        formattedTimeRemaining: import('vue').ComputedRef<string>;
+        percentageRemaining: import('vue').ComputedRef<number>;
+        timerColor: import('vue').ComputedRef<"primary" | "orange darken-3">;
+        addSessionTime: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "add-time"[], "add-time", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        timeRemaining: {
+            type: NumberConstructor;
+            required: true;
+        };
+        sessionTimeLimit: {
+            type: NumberConstructor;
+            required: true;
+            default: number;
+        };
+    }>> & Readonly<{
+        "onAdd-time"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        sessionTimeLimit: number;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    SkMouseTrap: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        refreshInterval: {
+            type: PropType<import('./SkMouseTrap.types').SkMouseTrapProps["refreshInterval"]>;
+            default: number;
+        };
+    }>, {}, {
+        commands: import('..').HotKeyMetaData[];
+        display: boolean;
+        intervalId: number | null;
+    }, {}, {
+        refreshState(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        refreshInterval: {
+            type: PropType<import('./SkMouseTrap.types').SkMouseTrapProps["refreshInterval"]>;
+            default: number;
+        };
+    }>> & Readonly<{}>, {
+        refreshInterval: number | undefined;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    HeatMap: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        activityRecords: {
+            type: PropType<import('./HeatMap.types').ActivityRecord[]>;
+            default: () => never[];
+        };
+        activityRecordsGetter: {
+            type: PropType<() => Promise<import('./HeatMap.types').ActivityRecord[]>>;
+            default: null;
+        };
+        inactiveColor: {
+            type: PropType<import('./HeatMap.types').Color>;
+            default: () => {
+                h: number;
+                s: number;
+                l: number;
+            };
+        };
+        activeColor: {
+            type: PropType<import('./HeatMap.types').Color>;
+            default: () => {
+                h: number;
+                s: number;
+                l: number;
+            };
+        };
+        cellSize: {
+            type: NumberConstructor;
+            default: number;
+        };
+        cellMargin: {
+            type: NumberConstructor;
+            default: number;
+        };
+        enableSeasonalColors: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {
+        isLoading: boolean;
+        localActivityRecords: import('./HeatMap.types').ActivityRecord[];
+        heatmapData: {
+            [key: string]: number;
+        };
+        weeks: import('./HeatMap.types').DayData[][];
+        tooltipData: import('./HeatMap.types').DayData | null;
+        tooltipStyle: {
+            [key: string]: string;
+        };
+        maxInRange: number;
+    }, {
+        width(): number;
+        height(): number;
+        effectiveActivityRecords(): import('./HeatMap.types').ActivityRecord[];
+    }, {
+        toDateString(d: string): string;
+        processRecords(): void;
+        createWeeksData(): void;
+        getColor(count: number): string;
+        interpolate(start: number, end: number, t: number): number;
+        hslToString(color: import('./HeatMap.types').Color): string;
+        showTooltip(day: import('./HeatMap.types').DayData, event: MouseEvent): void;
+        hideTooltip(): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        activityRecords: {
+            type: PropType<import('./HeatMap.types').ActivityRecord[]>;
+            default: () => never[];
+        };
+        activityRecordsGetter: {
+            type: PropType<() => Promise<import('./HeatMap.types').ActivityRecord[]>>;
+            default: null;
+        };
+        inactiveColor: {
+            type: PropType<import('./HeatMap.types').Color>;
+            default: () => {
+                h: number;
+                s: number;
+                l: number;
+            };
+        };
+        activeColor: {
+            type: PropType<import('./HeatMap.types').Color>;
+            default: () => {
+                h: number;
+                s: number;
+                l: number;
+            };
+        };
+        cellSize: {
+            type: NumberConstructor;
+            default: number;
+        };
+        cellMargin: {
+            type: NumberConstructor;
+            default: number;
+        };
+        enableSeasonalColors: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        activityRecords: import('./HeatMap.types').ActivityRecord[];
+        activityRecordsGetter: () => Promise<import('./HeatMap.types').ActivityRecord[]>;
+        inactiveColor: import('./HeatMap.types').Color;
+        activeColor: import('./HeatMap.types').Color;
+        cellSize: number;
+        cellMargin: number;
+        enableSeasonalColors: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    SessionControllerDebug: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        sessionController: {
+            type: PropType<SessionController<any> | null>;
+            required: true;
+        };
+    }>, {
+        debugInfo: import('vue').ComputedRef<import('./SessionControllerDebug.vue').SessionDebugInfo>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        sessionController: {
+            type: PropType<SessionController<any> | null>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=StudySession.vue.d.ts.map

package/dist/components/StudySession.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StudySession.vue.d.ts","sourceRoot":"","sources":["../../src/components/StudySession.vue"],"names":[],"mappings":"AAuEA;AAAA,OAinBO,EAAE,eAAe,EAAW,QAAQ,EAAE,MAAM,KAAK,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAM/C,OAAO,UAAU,MAAM,gCAAgC,CAAC;AAGxD,OAAO,EAAE,SAAS,EAAuB,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,EACL,WAAW,EACX,UAAU,EAEV,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EAGjB,YAAY,EAGZ,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,UAAU,SAAS;IACjB,aAAa,EAAE,cAAc,CAAC;IAC9B,UAAU,EAAE,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;CAC7C;AAED,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,GAAG;IACxD,KAAK,EAAE,SAAS,CAAC;CAClB,CAAC;;;;;;;cAqBmB,QAAQ,CAAC,eAAe,EAAE,CAAC;;;;cAI1B,QAAQ,CAAC,eAAe,CAAC;;;;cAIzB,QAAQ,CAAC,iBAAiB,CAAC;;;;cAI3B,QAAQ,CAAC,kBAAkB,CAAC;;;;;;cAI1B,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,aAAa,CAAC;;;;;UAmB/C,aAAa,GAAG,IAAI;UACtB,QAAQ,EAAE;;;iBAGH;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE;;uBAEtB,iBAAiB,CAAC,aAAa,CAAC,GAAG,IAAI;;;mBAG7C,kBAAkB,EAAE;;;;sBAIf,qBAAqB,GAAG,IAAI;2BACzB,kBAAkB,EAAE;;qBAExB,MAAM,CAAC,OAAO,GAAG,IAAI;;;;mBAOjC,kBAAkB;;uBA4Cd,MAAM,GAAG,SAAS;kCASxB,OAAO;;;;8BA2HM,MAAM,WAAW,MAAM,GAAG,MAAM;0BAI9B,aAAa,KAAK,UAAU;6BAkE/B,cAAc;;qBAgDhB,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;mBAO/C,YAAY,GAAG,IAAI;;;;;;;cAvWvB,QAAQ,CAAC,eAAe,EAAE,CAAC;;;;cAI1B,QAAQ,CAAC,eAAe,CAAC;;;;cAIzB,QAAQ,CAAC,iBAAiB,CAAC;;;;cAI3B,QAAQ,CAAC,kBAAkB,CAAC;;;;;;cAI1B,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;wBApnBvD,QAAS,IAAI,CAAC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAxB,QAAS,IAAI,CAAC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAilBpC,wBAibG"}

package/dist/components/StudySessionTimer.vue.d.ts

@@ -0,0 +1,45 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /**
+     * Time remaining in seconds
+     */
+    timeRemaining: {
+        type: NumberConstructor;
+        required: true;
+    };
+    /**
+     * Total session time limit in minutes
+     */
+    sessionTimeLimit: {
+        type: NumberConstructor;
+        required: true;
+        default: number;
+    };
+}>, {
+    hovered: import('vue').Ref<boolean, boolean>;
+    formattedTimeRemaining: import('vue').ComputedRef<string>;
+    percentageRemaining: import('vue').ComputedRef<number>;
+    timerColor: import('vue').ComputedRef<"primary" | "orange darken-3">;
+    addSessionTime: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "add-time"[], "add-time", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /**
+     * Time remaining in seconds
+     */
+    timeRemaining: {
+        type: NumberConstructor;
+        required: true;
+    };
+    /**
+     * Total session time limit in minutes
+     */
+    sessionTimeLimit: {
+        type: NumberConstructor;
+        required: true;
+        default: number;
+    };
+}>> & Readonly<{
+    "onAdd-time"?: ((...args: any[]) => any) | undefined;
+}>, {
+    sessionTimeLimit: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=StudySessionTimer.vue.d.ts.map

package/dist/components/StudySessionTimer.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StudySessionTimer.vue.d.ts","sourceRoot":"","sources":["../../src/components/StudySessionTimer.vue"],"names":[],"mappings":"AA4BA;;IAiII;;OAEG;;;;;IAKH;;OAEG;;;;;;;;;;;;;IATH;;OAEG;;;;;IAKH;;OAEG;;;;;;;;;;;AAbP,wBAgFG"}

package/dist/components/TagsInput.vue.d.ts

@@ -0,0 +1,77 @@
+import { Tag, CourseDBInterface } from '../../../db/dist/index.mjs';
+export interface TagObject {
+    text: string;
+    style?: string;
+    classes?: string;
+    data?: {
+        snippet: string;
+    };
+}
+export interface TagsInputInstance {
+    tags: Array<{
+        text: string;
+        style?: string;
+        classes?: string;
+        data?: {
+            snippet: string;
+        };
+    }>;
+    submit: () => Promise<void>;
+    updateAvailableCourseTags: () => Promise<void>;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    courseID: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    cardID: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    hideSubmit: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>, {}, {
+    loading: boolean;
+    tag: string;
+    tags: TagObject[];
+    initialTags: string[];
+    availableCourseTags: Tag[];
+    separators: string[];
+    courseDB: CourseDBInterface | null;
+}, {
+    autoCompleteSuggestions(): TagObject[];
+}, {
+    tagsChanged(newTags: TagObject[]): void;
+    getAppliedTags(): Promise<void>;
+    updateAvailableCourseTags(): Promise<void>;
+    submit(): Promise<void>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    courseID: {
+        type: StringConstructor;
+        required: true;
+        default: string;
+    };
+    cardID: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    hideSubmit: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    cardID: string;
+    courseID: string;
+    hideSubmit: boolean;
+}, {}, {
+    VueTagsInput: any;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=TagsInput.vue.d.ts.map

package/dist/components/TagsInput.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TagsInput.vue.d.ts","sourceRoot":"","sources":["../../src/components/TagsInput.vue"],"names":[],"mappings":"AAuBA;AA0PA,OAAO,EAAgB,GAAG,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAIxE,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE;QACL,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,KAAK,CAAC;QACV,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE;YACL,OAAO,EAAE,MAAM,CAAC;SACjB,CAAC;KACH,CAAC,CAAC;IACH,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,yBAAyB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;;;;;;;;;;;;;;;;;;;;UA+BiB,SAAS,EAAE;iBACJ,MAAM,EAAE;yBACA,GAAG,EAAE;gBACD,MAAM,EAAE;cACrB,iBAAiB,GAAG,IAAI;;+BAKjB,SAAS,EAAE;;yBAkCjB,SAAS,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;AAxEpC,wBA0JG"}

package/dist/components/auth/RequestPasswordReset.vue.d.ts

@@ -0,0 +1,15 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {
+    email: string;
+    emailError: boolean;
+    emailHint: string;
+    isSubmitting: boolean;
+    requestSent: boolean;
+}, {}, {
+    validateEmail(): void;
+    handleSubmit(): Promise<void>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("cancel" | "success")[], "cancel" | "success", import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onSuccess?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=RequestPasswordReset.vue.d.ts.map

package/dist/components/auth/RequestPasswordReset.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestPasswordReset.vue.d.ts","sourceRoot":"","sources":["../../../src/components/auth/RequestPasswordReset.vue"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;AA0IA,wBA8DG"}

package/dist/components/auth/ResetPassword.vue.d.ts

@@ -0,0 +1,38 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /**
+     * Reset token. If not provided, will try to read from URL query params.
+     */
+    token: {
+        type: StringConstructor;
+        default: null;
+    };
+}>, {}, {
+    password: string;
+    confirmPassword: string;
+    passwordVisible: boolean;
+    confirmPasswordError: boolean;
+    confirmPasswordHint: string;
+    isSubmitting: boolean;
+    isComplete: boolean;
+}, {
+    canSubmit(): boolean;
+}, {
+    validateConfirmPassword(): void;
+    handleSubmit(): Promise<void>;
+    getTokenFromURL(): string | null;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("error" | "complete")[], "error" | "complete", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /**
+     * Reset token. If not provided, will try to read from URL query params.
+     */
+    token: {
+        type: StringConstructor;
+        default: null;
+    };
+}>> & Readonly<{
+    onError?: ((...args: any[]) => any) | undefined;
+    onComplete?: ((...args: any[]) => any) | undefined;
+}>, {
+    token: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=ResetPassword.vue.d.ts.map

package/dist/components/auth/ResetPassword.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResetPassword.vue.d.ts","sourceRoot":"","sources":["../../../src/components/auth/ResetPassword.vue"],"names":[],"mappings":"AAyEA;;IAyMI;;OAEG;;;;;;;;;;;;;;iBAoBU,OAAO;;;;uBAuED,MAAM,GAAG,IAAI;;IA7FhC;;OAEG;;;;;;;;;;;AARP,wBA0GG"}

package/dist/components/auth/UserChip.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    showLoginButton?: boolean;
+    redirectToPath?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=UserChip.vue.d.ts.map

package/dist/components/auth/UserChip.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserChip.vue.d.ts","sourceRoot":"","sources":["../../../src/components/auth/UserChip.vue"],"names":[],"mappings":"AA2FA;AAgNA,KAAK,WAAW,GAAG;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;;AA+jBF,wBAMG"}

package/dist/components/auth/UserLogin.vue.d.ts

@@ -0,0 +1,31 @@
+interface Props {
+    redirectTo?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'forgot-password'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    toggle: () => any;
+    loginSuccess: (redirectPath: string) => any;
+    forgotPassword: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onToggle?: (() => any) | undefined;
+    onLoginSuccess?: ((redirectPath: string) => any) | undefined;
+    onForgotPassword?: (() => any) | undefined;
+}>, {
+    redirectTo: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=UserLogin.vue.d.ts.map

package/dist/components/auth/UserLogin.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserLogin.vue.d.ts","sourceRoot":"","sources":["../../../src/components/auth/UserLogin.vue"],"names":[],"mappings":"AA2DA;AAsMA,UAAU,KAAK;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAkHD,iBAAS,cAAc;WAuPT,OAAO,IAA6B;;mCAVV,GAAG;;;;EAe1C;AAqBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;gBArYN,MAAM;6EA8YnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/auth/UserLoginAndRegistrationContainer.vue.d.ts

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    showLoginButton?: boolean;
+    redirectToPath?: string;
+    showRegistration?: boolean;
+    onSignupSuccess?: (payload: {
+        username: string;
+    }) => void;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "signup-success": (payload: {
+        username: string;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onSignup-success"?: ((payload: {
+        username: string;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=UserLoginAndRegistrationContainer.vue.d.ts.map