declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    /**
     * Whether to disable the Apply button
     */
    disableApply: BooleanConstructor;
    /**
     * Whether to disable the Clear button
     */
    disableClear: BooleanConstructor;
    /**
     * Whether to disable the sticky filters
     * If disabled, a default pre-selected value(s) can be added to
     * the filter component's attributes
     */
    disablePersistency: BooleanConstructor;
    /**
     * Filters schema
     */
    schema: {
        type: ArrayConstructor;
        default: () => never[];
    };
    /**
     * Validation schema function that returns an object
     */
    validationSchema: {
        type: FunctionConstructor;
        default: () => () => undefined;
    };
}>, {
    validation: import("vue").Ref<any, any>;
    validationValues: import("vue").Ref<{}, {}>;
    initValidation: () => void;
}, {
    applyText: any;
    clearText: any;
    filters: {};
    filterValues: {};
    forceRenderCount: number;
}, {}, {
    initFilterValues(): void;
    /**
     * Apply the selected filters and save them to localStorage.
     * ListView calls this method using a ref to Filters.
     * The trigger option is used in ListView.
     * @param {object} [options] - optional parameters
     * @param {string} [options.trigger] - the action that triggered this function call
     */
    applyFilters({ trigger }?: {
        trigger?: string | undefined;
    }): Promise<void>;
    resetFilters(): void;
    /**
     * Returns pre-defined filter values to become the default values
     */
    getDefaultFilterValues(): unknown;
    /**
     * Intended for external use, when filter values need to be set for the user
     */
    setFilterValues(newValues: any): void;
    updateValidationValues(): void;
    /**
     * Change handler for filter fields
     */
    onChange(filter: any, filterValues: any, filterIndex: any): void;
    /**
     * Select input event handler for filter fields
     */
    onSelectInput(newValue: any, filter: any, filterIndex: any): void;
    /**
     * Get filter values from local storage.
     * @returns {any}
     */
    getPersistentFilterValues(): any;
    /**
     * Clone new filterValues to remove reactivity, and save them to localStorage.
     * @param {object} newValues - the filterValues to be persisted in localStorage
     */
    persistFilterValues(newValues: object): void;
}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("reset" | "submit" | "change")[], "reset" | "submit" | "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    /**
     * Whether to disable the Apply button
     */
    disableApply: BooleanConstructor;
    /**
     * Whether to disable the Clear button
     */
    disableClear: BooleanConstructor;
    /**
     * Whether to disable the sticky filters
     * If disabled, a default pre-selected value(s) can be added to
     * the filter component's attributes
     */
    disablePersistency: BooleanConstructor;
    /**
     * Filters schema
     */
    schema: {
        type: ArrayConstructor;
        default: () => never[];
    };
    /**
     * Validation schema function that returns an object
     */
    validationSchema: {
        type: FunctionConstructor;
        default: () => () => undefined;
    };
}>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    onReset?: ((...args: any[]) => any) | undefined;
    onSubmit?: ((...args: any[]) => any) | undefined;
}>, {
    schema: unknown[];
    disableApply: boolean;
    disableClear: boolean;
    disablePersistency: boolean;
    validationSchema: Function;
}, {}, {
    'll-button': {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
            color: "blue" | "red";
            icon: boolean;
            href: string;
            secondary: boolean;
            iconLabel: boolean;
            tertiary: boolean;
            inline: boolean;
            to: import("vue-router").RouteLocationRaw;
            isLoading: boolean;
            disabled: boolean;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
            color: "blue" | "red";
            icon: boolean;
            href: string;
            secondary: boolean;
            iconLabel: boolean;
            tertiary: boolean;
            inline: boolean;
            to: import("vue-router").RouteLocationRaw;
            isLoading: boolean;
            disabled: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
        color: "blue" | "red";
        icon: boolean;
        href: string;
        secondary: boolean;
        iconLabel: boolean;
        tertiary: boolean;
        inline: boolean;
        to: import("vue-router").RouteLocationRaw;
        isLoading: boolean;
        disabled: boolean;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            default?: (props: {}) => any;
        };
    });
    'll-checkbox': {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
            "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            "update:checked": (value: boolean | (string | number)[]) => any;
        }, import("vue").PublicProps, {
            id: string;
            label: string;
            disabled: boolean;
            value: string | number;
            modelValue: boolean | Array<string | number>;
            hasError: boolean;
            errorText: string;
            hintText: string;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
            "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
        }>, {}, {}, {}, {}, {
            id: string;
            label: string;
            disabled: boolean;
            value: string | number;
            modelValue: boolean | Array<string | number>;
            hasError: boolean;
            errorText: string;
            hintText: string;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
        "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
        "update:checked": (value: boolean | (string | number)[]) => any;
    }, string, {
        id: string;
        label: string;
        disabled: boolean;
        value: string | number;
        modelValue: boolean | Array<string | number>;
        hasError: boolean;
        errorText: string;
        hintText: string;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            default?: (props: {}) => any;
        } & {
            hint?: (props: {}) => any;
        };
    });
    'll-input': {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Input.vue").InputProps> & Readonly<{
            onFocus?: ((evt: Event) => any) | undefined;
            onBlur?: ((evt: Event) => any) | undefined;
            onChange?: ((v: string | number) => any) | undefined;
            "onUpdate:model-value"?: ((v: string | number) => any) | undefined;
        }>, {
            inputEl: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            focus: (evt: Event) => any;
            blur: (evt: Event) => any;
            change: (v: string | number) => any;
            "update:model-value": (v: string | number) => any;
        }, import("vue").PublicProps, {
            type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
            value: string | number | null;
            modelValue: string | number;
            placeholder: string;
            autocomplete: string;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Input.vue").InputProps> & Readonly<{
            onFocus?: ((evt: Event) => any) | undefined;
            onBlur?: ((evt: Event) => any) | undefined;
            onChange?: ((v: string | number) => any) | undefined;
            "onUpdate:model-value"?: ((v: string | number) => any) | undefined;
        }>, {
            inputEl: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
        }, {}, {}, {}, {
            type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
            value: string | number | null;
            modelValue: string | number;
            placeholder: string;
            autocomplete: string;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Input.vue").InputProps> & Readonly<{
        onFocus?: ((evt: Event) => any) | undefined;
        onBlur?: ((evt: Event) => any) | undefined;
        onChange?: ((v: string | number) => any) | undefined;
        "onUpdate:model-value"?: ((v: string | number) => any) | undefined;
    }>, {
        inputEl: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
        focus: (evt: Event) => any;
        blur: (evt: Event) => any;
        change: (v: string | number) => any;
        "update:model-value": (v: string | number) => any;
    }, string, {
        type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
        value: string | number | null;
        modelValue: string | number;
        placeholder: string;
        autocomplete: string;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            prepend?: (props: {}) => any;
        } & {
            append?: (props: {}) => any;
        } & {
            hint?: (props: {}) => any;
        };
    });
    'll-input-options': {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./InputOptions.vue").InputOptionsProps> & Readonly<{
            onChange?: ((v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any) | undefined;
            "onUpdate:model-value"?: ((v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            change: (v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any;
            "update:model-value": (v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any;
        }, import("vue").PublicProps, {
            type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
            options: any[];
            modelValue: {
                value: string;
                option?: any;
            };
            placeholder: string;
            trackBy: string;
            displayBy: string;
            noTruncate: boolean;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./InputOptions.vue").InputOptionsProps> & Readonly<{
            onChange?: ((v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any) | undefined;
            "onUpdate:model-value"?: ((v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any) | undefined;
        }>, {}, {}, {}, {}, {
            type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
            options: any[];
            modelValue: {
                value: string;
                option?: any;
            };
            placeholder: string;
            trackBy: string;
            displayBy: string;
            noTruncate: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./InputOptions.vue").InputOptionsProps> & Readonly<{
        onChange?: ((v: {
            value?: string;
            option?: any;
            isValueChange: boolean;
            type: "input" | "select";
        }) => any) | undefined;
        "onUpdate:model-value"?: ((v: {
            value?: string;
            option?: any;
            isValueChange: boolean;
            type: "input" | "select";
        }) => any) | undefined;
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
        change: (v: {
            value?: string;
            option?: any;
            isValueChange: boolean;
            type: "input" | "select";
        }) => any;
        "update:model-value": (v: {
            value?: string;
            option?: any;
            isValueChange: boolean;
            type: "input" | "select";
        }) => any;
    }, string, {
        type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
        options: any[];
        modelValue: {
            value: string;
            option?: any;
        };
        placeholder: string;
        trackBy: string;
        displayBy: string;
        noTruncate: boolean;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            default: (props: {
                fieldId: string;
            }) => void;
            hint: () => unknown;
        };
    });
    'll-radio': import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        checked: {
            type: (StringConstructor | NumberConstructor)[];
            default: undefined;
        };
        modelValue: {
            type: (StringConstructor | NumberConstructor | null)[];
            default: null;
            validator(value: unknown): true;
        };
        hasError: BooleanConstructor;
        id: {
            type: StringConstructor;
            required: true;
        };
        label: {
            type: StringConstructor;
            default: string;
        };
    }>, {
        classes: Record<string, string>;
    }, {}, {
        internalValue: {
            get(): string | number | undefined;
            set(value: any): void;
        };
    }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:checked"[], "update:checked", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        checked: {
            type: (StringConstructor | NumberConstructor)[];
            default: undefined;
        };
        modelValue: {
            type: (StringConstructor | NumberConstructor | null)[];
            default: null;
            validator(value: unknown): true;
        };
        hasError: BooleanConstructor;
        id: {
            type: StringConstructor;
            required: true;
        };
        label: {
            type: StringConstructor;
            default: string;
        };
    }>> & Readonly<{
        "onUpdate:checked"?: ((...args: any[]) => any) | undefined;
    }>, {
        label: string;
        modelValue: string | number | null;
        checked: string | number;
        hasError: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    'll-select': {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Select.vue").SelectProps> & Readonly<{
            onClear?: (() => any) | undefined;
            onAdd?: ((optionAdded: any) => any) | undefined;
            onRemove?: ((optionRemoved: any, index: number) => any) | undefined;
            "onUpdate:model-value"?: ((selectedOptions: any) => any) | undefined;
            onOpened?: (() => any) | undefined;
            onClosed?: ((selectedOptions: any) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            clear: () => any;
            add: (optionAdded: any) => any;
            remove: (optionRemoved: any, index: number) => any;
            "update:model-value": (selectedOptions: any) => any;
            opened: () => any;
            closed: (selectedOptions: any) => any;
        }, import("vue").PublicProps, {
            name: string;
            error: string;
            icon: string | boolean;
            value: any | null;
            options: any[] | readonly any[];
            modelValue: any;
            hint: string;
            placeholder: string;
            trackBy: string;
            preventEmpty: boolean;
            allowEmpty: string | boolean | null;
            displayBy: string;
            searchBy: string[];
            lazy: () => any[];
            hideSearch: boolean;
            searchable: string | boolean | null;
            preserveSearchTerm: boolean;
            disableFiltering: boolean;
            single: boolean;
            noTruncate: boolean;
            loading: boolean;
            searchLoading: boolean;
            selectItemType: string;
            hideCheck: boolean;
            searchPlaceholder: string;
            onSearch: (searchTerm: string) => Promise<void> | void;
            useFuzzySearch: boolean;
            menuPlacement: import("@floating-ui/vue").Placement;
            enableTeleport: boolean;
            teleportTo: string | HTMLElement;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Select.vue").SelectProps> & Readonly<{
            onClear?: (() => any) | undefined;
            onAdd?: ((optionAdded: any) => any) | undefined;
            onRemove?: ((optionRemoved: any, index: number) => any) | undefined;
            "onUpdate:model-value"?: ((selectedOptions: any) => any) | undefined;
            onOpened?: (() => any) | undefined;
            onClosed?: ((selectedOptions: any) => any) | undefined;
        }>, {}, {}, {}, {}, {
            name: string;
            error: string;
            icon: string | boolean;
            value: any | null;
            options: any[] | readonly any[];
            modelValue: any;
            hint: string;
            placeholder: string;
            trackBy: string;
            preventEmpty: boolean;
            allowEmpty: string | boolean | null;
            displayBy: string;
            searchBy: string[];
            lazy: () => any[];
            hideSearch: boolean;
            searchable: string | boolean | null;
            preserveSearchTerm: boolean;
            disableFiltering: boolean;
            single: boolean;
            noTruncate: boolean;
            loading: boolean;
            searchLoading: boolean;
            selectItemType: string;
            hideCheck: boolean;
            searchPlaceholder: string;
            onSearch: (searchTerm: string) => Promise<void> | void;
            useFuzzySearch: boolean;
            menuPlacement: import("@floating-ui/vue").Placement;
            enableTeleport: boolean;
            teleportTo: string | HTMLElement;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Select.vue").SelectProps> & Readonly<{
        onClear?: (() => any) | undefined;
        onAdd?: ((optionAdded: any) => any) | undefined;
        onRemove?: ((optionRemoved: any, index: number) => any) | undefined;
        "onUpdate:model-value"?: ((selectedOptions: any) => any) | undefined;
        onOpened?: (() => any) | undefined;
        onClosed?: ((selectedOptions: any) => any) | undefined;
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
        clear: () => any;
        add: (optionAdded: any) => any;
        remove: (optionRemoved: any, index: number) => any;
        "update:model-value": (selectedOptions: any) => any;
        opened: () => any;
        closed: (selectedOptions: any) => any;
    }, string, {
        name: string;
        error: string;
        icon: string | boolean;
        value: any | null;
        options: any[] | readonly any[];
        modelValue: any;
        hint: string;
        placeholder: string;
        trackBy: string;
        preventEmpty: boolean;
        allowEmpty: string | boolean | null;
        displayBy: string;
        searchBy: string[];
        lazy: () => any[];
        hideSearch: boolean;
        searchable: string | boolean | null;
        preserveSearchTerm: boolean;
        disableFiltering: boolean;
        single: boolean;
        noTruncate: boolean;
        loading: boolean;
        searchLoading: boolean;
        selectItemType: string;
        hideCheck: boolean;
        searchPlaceholder: string;
        onSearch: (searchTerm: string) => Promise<void> | void;
        useFuzzySearch: boolean;
        menuPlacement: import("@floating-ui/vue").Placement;
        enableTeleport: boolean;
        teleportTo: string | HTMLElement;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            selected(props: {
                option: any;
                onRemove: () => void;
                chipSelectedClass: string;
            }): unknown;
            option(props: {
                option: any;
            }): unknown;
            'no-options'(): unknown;
            hint(): unknown;
        };
    });
    DatePicker: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./_internal/components/DatePicker/DatePicker.types").DatePickerProps> & Readonly<{
            onBlur?: (() => any) | undefined;
            "onUpdate:model-value"?: ((date: string | number | Date) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            blur: () => any;
            "update:model-value": (date: string | number | Date) => any;
        }, import("vue").PublicProps, {
            id: string;
            name: string;
            label: string;
            disabled: boolean;
            mode: "date" | "dateTime" | "time";
            modelValue: string;
            errorText: string;
            hintText: string;
            format: string;
            addBottomSpace: boolean;
            placeholder: string;
            timeZone: string;
            enableTeleport: boolean;
            availableDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
            disabledDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
            hideClearButton: boolean;
            isInputReadonly: boolean;
            maxDate: Date;
            minDate: Date;
            maxPage: {
                month: number;
                year: number;
            };
            minPage: {
                month: number;
                year: number;
            };
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./_internal/components/DatePicker/DatePicker.types").DatePickerProps> & Readonly<{
            onBlur?: (() => any) | undefined;
            "onUpdate:model-value"?: ((date: string | number | Date) => any) | undefined;
        }>, {}, {}, {}, {}, {
            id: string;
            name: string;
            label: string;
            disabled: boolean;
            mode: "date" | "dateTime" | "time";
            modelValue: string;
            errorText: string;
            hintText: string;
            format: string;
            addBottomSpace: boolean;
            placeholder: string;
            timeZone: string;
            enableTeleport: boolean;
            availableDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
            disabledDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
            hideClearButton: boolean;
            isInputReadonly: boolean;
            maxDate: Date;
            minDate: Date;
            maxPage: {
                month: number;
                year: number;
            };
            minPage: {
                month: number;
                year: number;
            };
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./_internal/components/DatePicker/DatePicker.types").DatePickerProps> & Readonly<{
        onBlur?: (() => any) | undefined;
        "onUpdate:model-value"?: ((date: string | number | Date) => any) | undefined;
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
        blur: () => any;
        "update:model-value": (date: string | number | Date) => any;
    }, string, {
        id: string;
        name: string;
        label: string;
        disabled: boolean;
        mode: "date" | "dateTime" | "time";
        modelValue: string;
        errorText: string;
        hintText: string;
        format: string;
        addBottomSpace: boolean;
        placeholder: string;
        timeZone: string;
        enableTeleport: boolean;
        availableDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
        disabledDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
        hideClearButton: boolean;
        isInputReadonly: boolean;
        maxDate: Date;
        minDate: Date;
        maxPage: {
            month: number;
            year: number;
        };
        minPage: {
            month: number;
            year: number;
        };
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            hint?: (props: {}) => any;
        };
    });
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;