@bagelink/vue 0.0.1218 → 0.0.1224

package/dist/components/Calendar/Index.vue.d.ts

@@ -0,0 +1,514 @@
+import { PropType } from 'vue';
+import { ConfigInterface } from './typings/config.interface';
+import { DayInterface } from './typings/interfaces/day.interface';
+import { EventInterface } from './typings/interfaces/event.interface';
+import { PeriodInterface } from './typings/interfaces/period.interface';
+import { modeType } from './typings/types';
+import { default as Time } from './helpers/Time';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        weekDayEvent?(_: {
+            eventData: {
+                id: import('./typings/interfaces/event.interface').EventID;
+                title?: string | undefined;
+                time: {
+                    start: string;
+                    end: string;
+                };
+                description?: string | undefined;
+                topic?: string | undefined;
+                location?: string | undefined;
+                with?: string | undefined;
+                colorScheme?: string | undefined;
+                color?: import('./typings/interfaces/event.interface').EventColor | undefined;
+                isEditable?: boolean | undefined;
+                disableDnD?: modeType[] | undefined;
+                disableResize?: modeType[] | undefined;
+                isCustom?: boolean | modeType[] | undefined;
+                zIndex?: number | undefined;
+                nOfPreviousConcurrentEvents?: number | undefined;
+                totalConcurrentEvents?: number | undefined;
+                timeJS?: {
+                    start: Date;
+                    end: Date;
+                } | undefined;
+                originalEvent?: {
+                    with?: string | undefined;
+                    time: {
+                        start: string;
+                        end: string;
+                    };
+                    title?: string | undefined;
+                    id: import('./typings/interfaces/event.interface').EventID;
+                    color?: import('./typings/interfaces/event.interface').EventColor | undefined;
+                    description?: string | undefined;
+                    topic?: string | undefined;
+                    location?: string | undefined;
+                    colorScheme?: string | undefined;
+                    isEditable?: boolean | undefined;
+                    disableDnD?: modeType[] | undefined;
+                    disableResize?: modeType[] | undefined;
+                    isCustom?: boolean | modeType[] | undefined;
+                    zIndex?: number | undefined;
+                    nOfPreviousConcurrentEvents?: number | undefined;
+                    totalConcurrentEvents?: number | undefined;
+                    timeJS?: {
+                        start: Date;
+                        end: Date;
+                    } | undefined;
+                    eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
+                } | undefined;
+                eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
+            };
+        }): any;
+        eventDialog?(_: {
+            eventDialogData: {
+                id: import('./typings/interfaces/event.interface').EventID;
+                title?: string | undefined;
+                time: {
+                    start: string;
+                    end: string;
+                };
+                description?: string | undefined;
+                topic?: string | undefined;
+                location?: string | undefined;
+                with?: string | undefined;
+                colorScheme?: string | undefined;
+                color?: import('./typings/interfaces/event.interface').EventColor | undefined;
+                isEditable?: boolean | undefined;
+                disableDnD?: modeType[] | undefined;
+                disableResize?: modeType[] | undefined;
+                isCustom?: boolean | modeType[] | undefined;
+                zIndex?: number | undefined;
+                nOfPreviousConcurrentEvents?: number | undefined;
+                totalConcurrentEvents?: number | undefined;
+                timeJS?: {
+                    start: Date;
+                    end: Date;
+                } | undefined;
+                originalEvent?: {
+                    with?: string | undefined;
+                    time: {
+                        start: string;
+                        end: string;
+                    };
+                    title?: string | undefined;
+                    id: import('./typings/interfaces/event.interface').EventID;
+                    color?: import('./typings/interfaces/event.interface').EventColor | undefined;
+                    description?: string | undefined;
+                    topic?: string | undefined;
+                    location?: string | undefined;
+                    colorScheme?: string | undefined;
+                    isEditable?: boolean | undefined;
+                    disableDnD?: modeType[] | undefined;
+                    disableResize?: modeType[] | undefined;
+                    isCustom?: boolean | modeType[] | undefined;
+                    zIndex?: number | undefined;
+                    nOfPreviousConcurrentEvents?: number | undefined;
+                    totalConcurrentEvents?: number | undefined;
+                    timeJS?: {
+                        start: Date;
+                        end: Date;
+                    } | undefined;
+                    eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
+                } | undefined;
+                eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
+            } | null;
+            closeEventDialog: () => void;
+        }): any;
+        eventDialog?(_: {
+            eventDialogData: {
+                id: import('./typings/interfaces/event.interface').EventID;
+                title?: string | undefined;
+                time: {
+                    start: string;
+                    end: string;
+                };
+                description?: string | undefined;
+                topic?: string | undefined;
+                location?: string | undefined;
+                with?: string | undefined;
+                colorScheme?: string | undefined;
+                color?: import('./typings/interfaces/event.interface').EventColor | undefined;
+                isEditable?: boolean | undefined;
+                disableDnD?: modeType[] | undefined;
+                disableResize?: modeType[] | undefined;
+                isCustom?: boolean | modeType[] | undefined;
+                zIndex?: number | undefined;
+                nOfPreviousConcurrentEvents?: number | undefined;
+                totalConcurrentEvents?: number | undefined;
+                timeJS?: {
+                    start: Date;
+                    end: Date;
+                } | undefined;
+                originalEvent?: {
+                    with?: string | undefined;
+                    time: {
+                        start: string;
+                        end: string;
+                    };
+                    title?: string | undefined;
+                    id: import('./typings/interfaces/event.interface').EventID;
+                    color?: import('./typings/interfaces/event.interface').EventColor | undefined;
+                    description?: string | undefined;
+                    topic?: string | undefined;
+                    location?: string | undefined;
+                    colorScheme?: string | undefined;
+                    isEditable?: boolean | undefined;
+                    disableDnD?: modeType[] | undefined;
+                    disableResize?: modeType[] | undefined;
+                    isCustom?: boolean | modeType[] | undefined;
+                    zIndex?: number | undefined;
+                    nOfPreviousConcurrentEvents?: number | undefined;
+                    totalConcurrentEvents?: number | undefined;
+                    timeJS?: {
+                        start: Date;
+                        end: Date;
+                    } | undefined;
+                    eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
+                } | undefined;
+                eventType?: import('./typings/interfaces/event.interface').EVENT_TYPE | undefined;
+            } | null;
+            closeEventDialog: () => void;
+        }): any;
+        customCurrentTime?(_: {}): any;
+        monthEvent?(_: {
+            eventData: EventInterface;
+        }): any;
+        dayCell?(_: {
+            dayData: DayInterface;
+        }): any;
+    };
+    refs: {
+        calendarRoot: HTMLDivElement;
+        appHeaderRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            config: {
+                type: PropType<ConfigInterface>;
+                default: () => {};
+            };
+            mode: {
+                type: PropType<modeType>;
+                default: string;
+            };
+            time: {
+                type: PropType<Time>;
+                default: () => {};
+            };
+            period: {
+                type: PropType<PeriodInterface>;
+                required: true;
+            };
+            isSmall: {
+                type: BooleanConstructor;
+                required: true;
+            };
+        }>> & Readonly<{
+            onChangeMode?: ((mode: modeType) => any) | undefined;
+            onUpdatedPeriod?: ((value: PeriodInterface) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            changeMode: (mode: modeType) => any;
+            updatedPeriod: (value: PeriodInterface) => any;
+        }, import('vue').PublicProps, {
+            time: Time;
+            mode: modeType;
+            config: ConfigInterface;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            periodSelect: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+                required?: boolean;
+                label?: string;
+                editMode?: boolean;
+                small?: boolean;
+                enableTime?: boolean;
+                modelValue?: string | Date;
+                min?: string | Date;
+                max?: string | Date;
+                timezone?: string;
+                mode?: modeType;
+                firstDayOfWeek?: import('./helpers/Time').WEEK_START_DAY;
+                locale?: string;
+                center?: boolean;
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (...args: any[]) => void;
+            }, import('vue').PublicProps, {
+                small: boolean;
+                mode: modeType;
+                editMode: boolean;
+                enableTime: boolean;
+                locale: string;
+                timezone: string;
+                firstDayOfWeek: import('./helpers/Time').WEEK_START_DAY;
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{
+                required?: boolean;
+                label?: string;
+                editMode?: boolean;
+                small?: boolean;
+                enableTime?: boolean;
+                modelValue?: string | Date;
+                min?: string | Date;
+                max?: string | Date;
+                timezone?: string;
+                mode?: modeType;
+                firstDayOfWeek?: import('./helpers/Time').WEEK_START_DAY;
+                locale?: string;
+                center?: boolean;
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            }>, {}, {}, {}, {}, {
+                small: boolean;
+                mode: modeType;
+                editMode: boolean;
+                enableTime: boolean;
+                locale: string;
+                timezone: string;
+                firstDayOfWeek: import('./helpers/Time').WEEK_START_DAY;
+            }> | null;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            config: {
+                type: PropType<ConfigInterface>;
+                default: () => {};
+            };
+            mode: {
+                type: PropType<modeType>;
+                default: string;
+            };
+            time: {
+                type: PropType<Time>;
+                default: () => {};
+            };
+            period: {
+                type: PropType<PeriodInterface>;
+                required: true;
+            };
+            isSmall: {
+                type: BooleanConstructor;
+                required: true;
+            };
+        }>> & Readonly<{
+            onChangeMode?: ((mode: modeType) => any) | undefined;
+            onUpdatedPeriod?: ((value: PeriodInterface) => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            time: Time;
+            mode: modeType;
+            config: ConfigInterface;
+        }> | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<ConfigInterface>;
+        default: () => {};
+    };
+    events: {
+        type: PropType<EventInterface[]>;
+        default: () => never[];
+    };
+    selectedDate: {
+        type: DateConstructor;
+        default: Date;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    updatedPeriod: (...args: any[]) => void;
+    eventWasClicked: (...args: any[]) => void;
+    editEvent: (...args: any[]) => void;
+    deleteEvent: (...args: any[]) => void;
+    eventWasDragged: (...args: any[]) => void;
+    dateWasClicked: (...args: any[]) => void;
+    eventWasResized: (...args: any[]) => void;
+    intervalWasClicked: (...args: any[]) => void;
+    dayWasClicked: (...args: any[]) => void;
+    datetimeWasClicked: (...args: any[]) => void;
+    updatedMode: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<ConfigInterface>;
+        default: () => {};
+    };
+    events: {
+        type: PropType<EventInterface[]>;
+        default: () => never[];
+    };
+    selectedDate: {
+        type: DateConstructor;
+        default: Date;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onUpdatedPeriod?: ((...args: any[]) => any) | undefined;
+    onEventWasClicked?: ((...args: any[]) => any) | undefined;
+    onEditEvent?: ((...args: any[]) => any) | undefined;
+    onDeleteEvent?: ((...args: any[]) => any) | undefined;
+    onEventWasDragged?: ((...args: any[]) => any) | undefined;
+    onDateWasClicked?: ((...args: any[]) => any) | undefined;
+    onEventWasResized?: ((...args: any[]) => any) | undefined;
+    onIntervalWasClicked?: ((...args: any[]) => any) | undefined;
+    onDayWasClicked?: ((...args: any[]) => any) | undefined;
+    onDatetimeWasClicked?: ((...args: any[]) => any) | undefined;
+    onUpdatedMode?: ((...args: any[]) => any) | undefined;
+}>, {
+    config: ConfigInterface;
+    selectedDate: Date;
+    events: EventInterface[];
+    isLoading: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    calendarRoot: HTMLDivElement;
+    appHeaderRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        config: {
+            type: PropType<ConfigInterface>;
+            default: () => {};
+        };
+        mode: {
+            type: PropType<modeType>;
+            default: string;
+        };
+        time: {
+            type: PropType<Time>;
+            default: () => {};
+        };
+        period: {
+            type: PropType<PeriodInterface>;
+            required: true;
+        };
+        isSmall: {
+            type: BooleanConstructor;
+            required: true;
+        };
+    }>> & Readonly<{
+        onChangeMode?: ((mode: modeType) => any) | undefined;
+        onUpdatedPeriod?: ((value: PeriodInterface) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        changeMode: (mode: modeType) => any;
+        updatedPeriod: (value: PeriodInterface) => any;
+    }, import('vue').PublicProps, {
+        time: Time;
+        mode: modeType;
+        config: ConfigInterface;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        periodSelect: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            required?: boolean;
+            label?: string;
+            editMode?: boolean;
+            small?: boolean;
+            enableTime?: boolean;
+            modelValue?: string | Date;
+            min?: string | Date;
+            max?: string | Date;
+            timezone?: string;
+            mode?: modeType;
+            firstDayOfWeek?: import('./helpers/Time').WEEK_START_DAY;
+            locale?: string;
+            center?: boolean;
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (...args: any[]) => void;
+        }, import('vue').PublicProps, {
+            small: boolean;
+            mode: modeType;
+            editMode: boolean;
+            enableTime: boolean;
+            locale: string;
+            timezone: string;
+            firstDayOfWeek: import('./helpers/Time').WEEK_START_DAY;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            required?: boolean;
+            label?: string;
+            editMode?: boolean;
+            small?: boolean;
+            enableTime?: boolean;
+            modelValue?: string | Date;
+            min?: string | Date;
+            max?: string | Date;
+            timezone?: string;
+            mode?: modeType;
+            firstDayOfWeek?: import('./helpers/Time').WEEK_START_DAY;
+            locale?: string;
+            center?: boolean;
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            small: boolean;
+            mode: modeType;
+            editMode: boolean;
+            enableTime: boolean;
+            locale: string;
+            timezone: string;
+            firstDayOfWeek: import('./helpers/Time').WEEK_START_DAY;
+        }> | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        config: {
+            type: PropType<ConfigInterface>;
+            default: () => {};
+        };
+        mode: {
+            type: PropType<modeType>;
+            default: string;
+        };
+        time: {
+            type: PropType<Time>;
+            default: () => {};
+        };
+        period: {
+            type: PropType<PeriodInterface>;
+            required: true;
+        };
+        isSmall: {
+            type: BooleanConstructor;
+            required: true;
+        };
+    }>> & Readonly<{
+        onChangeMode?: ((mode: modeType) => any) | undefined;
+        onUpdatedPeriod?: ((value: PeriodInterface) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        time: Time;
+        mode: modeType;
+        config: ConfigInterface;
+    }> | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=Index.vue.d.ts.map

package/dist/components/Calendar/Index.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Index.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Calendar/Index.vue"],"names":[],"mappings":"AAAA,OAmaO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAA;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAA;AAC5E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAO/C,OAAO,IAAI,MAAM,gBAAgB,CAAA;AA4MjC,iBAAS,cAAc;WAwTT,OAAO,IAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAjBf,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YACJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAEH,GAAG;mCADG,GAAG;;;YAEV,GAAG;;;YACN,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBhC;AA6CD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;cAQH,QAAQ,CAAC,eAAe,CAAC;;;;cAI1B,QAAQ,CAAC,cAAc,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;cAJzB,QAAQ,CAAC,eAAe,CAAC;;;;cAI1B,QAAQ,CAAC,cAAc,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAczC,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAEpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/Calendar/components/header/Header.vue.d.ts

@@ -0,0 +1,119 @@
+import { PropType } from 'vue';
+import { default as Time } from '../../helpers/Time';
+import { ConfigInterface } from '../../typings/config.interface';
+import { PeriodInterface } from '../../typings/interfaces/period.interface';
+import { modeType } from '../../typings/types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<ConfigInterface>;
+        default: () => {};
+    };
+    mode: {
+        type: PropType<modeType>;
+        default: string;
+    };
+    time: {
+        type: PropType<Time>;
+        default: () => {};
+    };
+    period: {
+        type: PropType<PeriodInterface>;
+        required: true;
+    };
+    isSmall: {
+        type: BooleanConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    changeMode: (mode: modeType) => any;
+    updatedPeriod: (value: PeriodInterface) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    config: {
+        type: PropType<ConfigInterface>;
+        default: () => {};
+    };
+    mode: {
+        type: PropType<modeType>;
+        default: string;
+    };
+    time: {
+        type: PropType<Time>;
+        default: () => {};
+    };
+    period: {
+        type: PropType<PeriodInterface>;
+        required: true;
+    };
+    isSmall: {
+        type: BooleanConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    onChangeMode?: ((mode: modeType) => any) | undefined;
+    onUpdatedPeriod?: ((value: PeriodInterface) => any) | undefined;
+}>, {
+    time: Time;
+    mode: modeType;
+    config: ConfigInterface;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    periodSelect: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        required?: boolean;
+        label?: string;
+        editMode?: boolean;
+        small?: boolean;
+        enableTime?: boolean;
+        modelValue?: string | Date;
+        min?: string | Date;
+        max?: string | Date;
+        timezone?: string;
+        mode?: modeType;
+        firstDayOfWeek?: import('../../helpers/Time').WEEK_START_DAY;
+        locale?: string;
+        center?: boolean;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (...args: any[]) => void;
+    }, import('vue').PublicProps, {
+        small: boolean;
+        mode: modeType;
+        editMode: boolean;
+        enableTime: boolean;
+        locale: string;
+        timezone: string;
+        firstDayOfWeek: import('../../helpers/Time').WEEK_START_DAY;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        required?: boolean;
+        label?: string;
+        editMode?: boolean;
+        small?: boolean;
+        enableTime?: boolean;
+        modelValue?: string | Date;
+        min?: string | Date;
+        max?: string | Date;
+        timezone?: string;
+        mode?: modeType;
+        firstDayOfWeek?: import('../../helpers/Time').WEEK_START_DAY;
+        locale?: string;
+        center?: boolean;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        small: boolean;
+        mode: modeType;
+        editMode: boolean;
+        enableTime: boolean;
+        locale: string;
+        timezone: string;
+        firstDayOfWeek: import('../../helpers/Time').WEEK_START_DAY;
+    }> | null;
+}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=Header.vue.d.ts.map

package/dist/components/Calendar/components/header/Header.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Header.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/Calendar/components/header/Header.vue"],"names":[],"mappings":"AAAA,OA0JO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AACnC,OAAO,KAAK,IAAI,MAAM,oBAAoB,CAAA;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAA;AAChF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;;;cA4SjC,QAAQ,CAAC,eAAe,CAAC;;;;cAIzB,QAAQ,CAAC,QAAQ,CAAC;;;;cAIlB,QAAQ,CAAC,IAAI,CAAC;;;;cAId,QAAQ,CAAC,eAAe,CAAC;;;;;;;;;;;;cAZzB,QAAQ,CAAC,eAAe,CAAC;;;;cAIzB,QAAQ,CAAC,QAAQ,CAAC;;;;cAIlB,QAAQ,CAAC,IAAI,CAAC;;;;cAId,QAAQ,CAAC,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AApB3C,wBA8BG"}

package/dist/components/Calendar/components/month/AgendaEventTile.vue.d.ts

@@ -0,0 +1,37 @@
+import { PropType } from 'vue';
+import { default as Time } from '../../helpers/Time';
+import { ConfigInterface } from '../../typings/config.interface';
+import { EventInterface } from '../../typings/interfaces/event.interface';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    time: {
+        type: PropType<Time>;
+        required: true;
+    };
+    calendarEvent: {
+        type: PropType<EventInterface>;
+        required: true;
+    };
+    config: {
+        type: PropType<ConfigInterface>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    eventWasClicked: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    time: {
+        type: PropType<Time>;
+        required: true;
+    };
+    calendarEvent: {
+        type: PropType<EventInterface>;
+        required: true;
+    };
+    config: {
+        type: PropType<ConfigInterface>;
+        required: true;
+    };
+}>> & Readonly<{
+    onEventWasClicked?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=AgendaEventTile.vue.d.ts.map

package/dist/components/Calendar/components/month/AgendaEventTile.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgendaEventTile.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/Calendar/components/month/AgendaEventTile.vue"],"names":[],"mappings":"AAkIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AACnC,OAAO,KAAK,IAAI,MAAM,oBAAoB,CAAA;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAA;;;cA4M5D,QAAQ,CAAC,IAAI,CAAC;;;;cAId,QAAQ,CAAC,cAAc,CAAC;;;;cAIxB,QAAQ,CAAC,eAAe,CAAC;;;;;;;cARzB,QAAQ,CAAC,IAAI,CAAC;;;;cAId,QAAQ,CAAC,cAAc,CAAC;;;;cAIxB,QAAQ,CAAC,eAAe,CAAC;;;;;;AAhB3C,wBAqBG"}