g-ui-web 1.4.21 → 1.4.22

package/lib/calendar/src/index.vue.d.ts

@@ -0,0 +1,793 @@
+import { nextTick } from 'vue';
+import { CalendarDateType } from 'element-plus';
+import { default as dayjs } from 'dayjs';
+declare function __VLS_template(): {
+    slots: {
+        legend?(_: {}): any;
+        todo?(_: {
+            data: any;
+        }): any;
+        todo?(_: {
+            data: any;
+        }): any;
+        todo?(_: {
+            data: any;
+        }): any;
+        todo?(_: {
+            data: any;
+        }): any;
+        "todo-dialog"?(_: {
+            data: any;
+        }): any;
+        "todo-dialog"?(_: {
+            data: any;
+        }): any;
+        monthHeader?(_: {
+            data: {
+                name: string;
+                value: string;
+            };
+        }): any;
+    };
+    refs: {
+        calendar: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{}> & Omit<{
+                readonly modelValue?: Date | undefined;
+                readonly range?: [Date, Date] | undefined;
+                "onUpdate:modelValue"?: ((value: Date) => any) | undefined | undefined;
+                onInput?: ((value: Date) => any) | undefined | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "input", value: Date) => void) & ((event: "update:modelValue", value: Date) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+                readonly modelValue: {
+                    readonly type: PropType<Date>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly range: {
+                    readonly type: PropType<[Date, Date]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((value: Date) => any) | undefined;
+                onInput?: ((value: Date) => any) | undefined;
+            }, {
+                selectedDay: WritableComputedRef<dayjs.Dayjs | undefined>;
+                pickDay: (day: dayjs.Dayjs) => void;
+                selectDate: (type: CalendarDateType) => void;
+                calculateValidatedDateRange: (startDayjs: dayjs.Dayjs, endDayjs: dayjs.Dayjs) => [dayjs.Dayjs, dayjs.Dayjs][];
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (value: Date) => void;
+                input: (value: Date) => void;
+            }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{}> & Omit<Readonly<globalThis.ExtractPropTypes<{
+            readonly modelValue: {
+                readonly type: PropType<Date>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly range: {
+                readonly type: PropType<[Date, Date]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((value: Date) => any) | undefined;
+            onInput?: ((value: Date) => any) | undefined;
+        }, "selectedDay" | "pickDay" | "selectDate" | "calculateValidatedDateRange"> & import('vue').ShallowUnwrapRef<{
+            selectedDay: WritableComputedRef<dayjs.Dayjs | undefined>;
+            pickDay: (day: dayjs.Dayjs) => void;
+            selectDate: (type: CalendarDateType) => void;
+            calculateValidatedDateRange: (startDayjs: dayjs.Dayjs, endDayjs: dayjs.Dayjs) => [dayjs.Dayjs, dayjs.Dayjs][];
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                header?(_: {
+                    date: string;
+                }): any;
+                "date-cell"?(_: {
+                    data: {
+                        isSelected: boolean;
+                        type: string;
+                        day: string;
+                        date: Date;
+                    };
+                }): any;
+                "date-cell"?(_: {
+                    data: {
+                        isSelected: boolean;
+                        type: string;
+                        day: string;
+                        date: Date;
+                    };
+                }): any;
+            };
+        }) | null;
+        popRef: (({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly disabled: boolean;
+                readonly width: string | number;
+                readonly content: string;
+                readonly offset: number;
+                readonly visible: boolean | null;
+                readonly placement: import('element-plus').Placement;
+                readonly effect: import('element-plus').PopperEffect;
+                readonly showAfter: number;
+                readonly hideAfter: number;
+                readonly autoClose: number;
+                readonly tabindex: string | number;
+                readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                readonly popperOptions: Partial<import('element-plus').Options>;
+                readonly enterable: boolean;
+                readonly triggerKeys: string[];
+                readonly teleported: boolean;
+                readonly persistent: boolean;
+                readonly showArrow: boolean;
+            }> & Omit<{
+                readonly visible: boolean | null;
+                readonly width: string | number;
+                readonly showArrow: boolean;
+                readonly disabled: boolean;
+                readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                readonly triggerKeys: string[];
+                readonly content: string;
+                readonly persistent: boolean;
+                readonly teleported: boolean;
+                readonly effect: import('element-plus').PopperEffect;
+                readonly enterable: boolean;
+                readonly placement: import('element-plus').Placement;
+                readonly popperOptions: Partial<import('element-plus').Options>;
+                readonly showAfter: number;
+                readonly hideAfter: number;
+                readonly autoClose: number;
+                readonly tabindex: string | number;
+                readonly title?: string | undefined;
+                readonly offset?: number | undefined;
+                readonly appendTo?: (string | HTMLElement) | undefined;
+                readonly transition?: string | undefined;
+                readonly popperClass?: (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]) | undefined;
+                readonly popperStyle?: import('vue').StyleValue;
+                "onUpdate:visible"?: (((visible: boolean) => void) & ((value: boolean) => any)) | undefined;
+                "onAfter-enter"?: (() => any) | undefined | undefined;
+                "onAfter-leave"?: (() => any) | undefined | undefined;
+                "onBefore-enter"?: (() => any) | undefined | undefined;
+                "onBefore-leave"?: (() => any) | undefined | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "offset" | "visible" | "width" | "showArrow" | "disabled" | "trigger" | "triggerKeys" | "content" | "persistent" | "teleported" | "effect" | "enterable" | "placement" | "popperOptions" | "showAfter" | "hideAfter" | "autoClose" | "tabindex">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "after-enter") => void) & ((event: "after-leave") => void) & ((event: "before-enter") => void) & ((event: "before-leave") => void) & ((event: "update:visible", value: boolean) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+                readonly trigger: {
+                    readonly type: globalThis.PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                readonly triggerKeys: {
+                    readonly type: globalThis.PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                readonly placement: {
+                    readonly type: globalThis.PropType<import('element-plus').Placement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                readonly disabled: BooleanConstructor;
+                readonly visible: {
+                    readonly type: globalThis.PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                readonly transition: StringConstructor;
+                readonly popperOptions: {
+                    readonly type: globalThis.PropType<Partial<import('element-plus').Options>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                readonly tabindex: {
+                    readonly type: globalThis.PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                readonly content: {
+                    readonly type: globalThis.PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly popperStyle: {
+                    readonly type: PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly popperClass: {
+                    readonly type: PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly enterable: {
+                    readonly default: true;
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    readonly __epPropKey: true;
+                };
+                readonly effect: {
+                    readonly default: "light";
+                    readonly type: PropType<import('element-plus').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    readonly __epPropKey: true;
+                };
+                readonly teleported: {
+                    readonly type: globalThis.PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly appendTo: {
+                    readonly type: PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly title: StringConstructor;
+                readonly width: {
+                    readonly type: globalThis.PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 150;
+                };
+                readonly offset: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly showAfter: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                readonly hideAfter: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                readonly autoClose: {
+                    readonly type: globalThis.PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                readonly showArrow: {
+                    readonly type: globalThis.PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly persistent: {
+                    readonly type: globalThis.PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly "onUpdate:visible": {
+                    readonly type: PropType<(visible: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>> & {
+                "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+                "onAfter-enter"?: (() => any) | undefined;
+                "onAfter-leave"?: (() => any) | undefined;
+                "onBefore-enter"?: (() => any) | undefined;
+                "onBefore-leave"?: (() => any) | undefined;
+            }, {
+                popperRef: ComputedRef<import('element-plus').PopperInstance | undefined>;
+                hide: () => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "after-enter": () => void;
+                "after-leave": () => void;
+                "before-enter": () => void;
+                "before-leave": () => void;
+                "update:visible": (value: boolean) => void;
+            }, string, {
+                readonly disabled: boolean;
+                readonly width: string | number;
+                readonly content: string;
+                readonly offset: number;
+                readonly visible: boolean | null;
+                readonly placement: import('element-plus').Placement;
+                readonly effect: import('element-plus').PopperEffect;
+                readonly showAfter: number;
+                readonly hideAfter: number;
+                readonly autoClose: number;
+                readonly tabindex: string | number;
+                readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                readonly popperOptions: Partial<import('element-plus').Options>;
+                readonly enterable: boolean;
+                readonly triggerKeys: string[];
+                readonly teleported: boolean;
+                readonly persistent: boolean;
+                readonly showArrow: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            readonly disabled: boolean;
+            readonly width: string | number;
+            readonly content: string;
+            readonly offset: number;
+            readonly visible: boolean | null;
+            readonly placement: import('element-plus').Placement;
+            readonly effect: import('element-plus').PopperEffect;
+            readonly showAfter: number;
+            readonly hideAfter: number;
+            readonly autoClose: number;
+            readonly tabindex: string | number;
+            readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+            readonly popperOptions: Partial<import('element-plus').Options>;
+            readonly enterable: boolean;
+            readonly triggerKeys: string[];
+            readonly teleported: boolean;
+            readonly persistent: boolean;
+            readonly showArrow: boolean;
+        }> & Omit<Readonly<globalThis.ExtractPropTypes<{
+            readonly trigger: {
+                readonly type: globalThis.PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "hover";
+            };
+            readonly triggerKeys: {
+                readonly type: globalThis.PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => string[];
+            };
+            readonly placement: {
+                readonly type: globalThis.PropType<import('element-plus').Placement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "bottom";
+            };
+            readonly disabled: BooleanConstructor;
+            readonly visible: {
+                readonly type: globalThis.PropType<boolean | null>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: null;
+            };
+            readonly transition: StringConstructor;
+            readonly popperOptions: {
+                readonly type: globalThis.PropType<Partial<import('element-plus').Options>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            readonly tabindex: {
+                readonly type: globalThis.PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly content: {
+                readonly type: globalThis.PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly popperStyle: {
+                readonly type: PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly popperClass: {
+                readonly type: PropType<string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly enterable: {
+                readonly default: true;
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                readonly __epPropKey: true;
+            };
+            readonly effect: {
+                readonly default: "light";
+                readonly type: PropType<import('element-plus').PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                readonly __epPropKey: true;
+            };
+            readonly teleported: {
+                readonly type: globalThis.PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly appendTo: {
+                readonly type: PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly title: StringConstructor;
+            readonly width: {
+                readonly type: globalThis.PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 150;
+            };
+            readonly offset: {
+                readonly type: globalThis.PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly showAfter: {
+                readonly type: globalThis.PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly hideAfter: {
+                readonly type: globalThis.PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 200;
+            };
+            readonly autoClose: {
+                readonly type: globalThis.PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly showArrow: {
+                readonly type: globalThis.PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly persistent: {
+                readonly type: globalThis.PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly "onUpdate:visible": {
+                readonly type: PropType<(visible: boolean) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+            "onAfter-enter"?: (() => any) | undefined;
+            "onAfter-leave"?: (() => any) | undefined;
+            "onBefore-enter"?: (() => any) | undefined;
+            "onBefore-leave"?: (() => any) | undefined;
+        }, "offset" | "visible" | "width" | "showArrow" | "disabled" | "trigger" | "triggerKeys" | "content" | "persistent" | "teleported" | "effect" | "enterable" | "placement" | "popperOptions" | "showAfter" | "hideAfter" | "autoClose" | "popperRef" | "hide" | "tabindex"> & import('vue').ShallowUnwrapRef<{
+            popperRef: ComputedRef<import('element-plus').PopperInstance | undefined>;
+            hide: () => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                reference?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) | null)[];
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    popWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isPop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDia: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isRadio: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dateType: {
+        type: StringConstructor;
+        default: string;
+    };
+    dbOptions: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    monthValue: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    yearValue: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    maxTodo: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:monthValue": (...args: any[]) => void;
+    "update:yearValue": (...args: any[]) => void;
+    changeMonth: (...args: any[]) => void;
+    changeYear: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    popWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isPop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDia: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isRadio: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dateType: {
+        type: StringConstructor;
+        default: string;
+    };
+    dbOptions: {
+        type: ObjectConstructor;
+        default: {};
+    };
+    monthValue: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    yearValue: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    maxTodo: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onUpdate:monthValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:yearValue"?: ((...args: any[]) => any) | undefined;
+    onChangeMonth?: ((...args: any[]) => any) | undefined;
+    onChangeYear?: ((...args: any[]) => any) | undefined;
+}>, {
+    dbOptions: Record<string, any>;
+    popWidth: number;
+    isPop: boolean;
+    isDia: boolean;
+    isRadio: boolean;
+    dateType: string;
+    monthValue: string;
+    yearValue: string;
+    maxTodo: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};