@octans/ui 1.0.0

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

@@ -0,0 +1,1627 @@
+import { ActionListItemType } from '../ActionList';
+import { SelectOptionType, SelectOptionGroupType } from '../Select';
+import { PropType } from 'vue';
+import { DebouncedFunc } from '../../utils/debounce';
+export interface FilterType {
+    type: string;
+    key: string;
+    label: string;
+    placeholder: string;
+    required: boolean;
+    modelFormat?: string;
+    endOfDay?: boolean;
+    options?: SelectOptionType[];
+    optionGroups?: SelectOptionGroupType[];
+    multiple?: boolean;
+}
+export interface FiltersShortcutType {
+    label: string;
+    items: ActionListItemType[];
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /**
+     * An array of filter objects. Each must have a unique `key` which corresponds
+     * to those used in `appliedFilters`.
+     *
+     * ```js
+     * interface Filter {
+     *   key: string // A unique key
+     *   label: string
+     *   type: 'datetime' | 'date' | 'month' | 'year' | 'text' | 'select' | 'boolean'
+     *   placeholder?: string
+     *   options?: object[] // Options for `select`
+     *   optionGroups?: object[] // Option groups for `select`
+     *   multiple?: boolean // For `select`
+     * }
+     * ```
+     */
+    filters: {
+        type: () => FilterType[];
+        default: () => never[];
+    };
+    /**
+     * The data representing applied filters. Each filter value is assigned
+     * to the `key` provided in the filter array definition.
+     *
+     * Use as `v-model:appliedFilters`.
+     *
+     * For example, if you defined two filters with keys "startDate" and "endDate" you
+     * would represent their current values using the following object:
+     *
+     * ```js
+     * {
+     *   startDate: null,
+     *   endDate: null
+     * }
+     * ```
+     */
+    appliedFilters: {
+        type: () => Record<string, any>;
+        default: () => {};
+    };
+    /**
+     * An optional array of shortcut filters which are added to the left
+     * of the query input.
+     *
+     * Each shortcut is represented as an ActionList.
+     *
+     * ```js
+     * interface Shortcut {
+     *   label: string
+     *   // See `ActionListItem` for more items options
+     *   items: Array<{
+     *     label: string
+     *     onAction(): void
+     *   }>
+     * }
+     * ```
+     */
+    shortcuts: {
+        type: () => FiltersShortcutType[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * The value to use in the query text field.
+     *
+     * Set this to `false` to disable querying.
+     */
+    query: {
+        type: PropType<string | null | false>;
+    };
+    /**
+     * The delay between emitting updated query values in milliseconds.
+     */
+    queryDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    mode: {
+        type: PropType<"single" | "multi">;
+        default: string;
+    };
+}>, {}, {
+    showSheet: boolean;
+    isOpen: boolean;
+    editFilters: Record<string, any>;
+    localQuery: string | null | boolean;
+    updateQueryDebounced: DebouncedFunc<(value: string) => void> | null;
+}, {
+    mergedFilters(): {
+        value: any;
+        type: string;
+        key: string;
+        label: string;
+        placeholder: string;
+        required: boolean;
+        modelFormat?: string;
+        endOfDay?: boolean;
+        options?: SelectOptionType[];
+        optionGroups?: SelectOptionGroupType[];
+        multiple?: boolean;
+    }[];
+    appliedTags(): any;
+    hasChanged(): boolean;
+    commitErrors(): string[];
+}, {
+    $t: typeof import('../../utils/translate').translate;
+    onUpdateFilterItemValue(key: string, val: any): void;
+    open(): void;
+    commit(): void;
+    cancel(): void;
+    removeValue(parentKey: string, val: any): void;
+    removeFilter(key: string): void;
+    emitAppliedFilters(filters: Record<string, any>): void;
+    getFilterByKey(key: string): FilterType | undefined;
+    showRequiredMessage(filter: FilterType): void;
+    updateQuery(value: string): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update:appliedFilters" | "update:query")[], "update:appliedFilters" | "update:query", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /**
+     * An array of filter objects. Each must have a unique `key` which corresponds
+     * to those used in `appliedFilters`.
+     *
+     * ```js
+     * interface Filter {
+     *   key: string // A unique key
+     *   label: string
+     *   type: 'datetime' | 'date' | 'month' | 'year' | 'text' | 'select' | 'boolean'
+     *   placeholder?: string
+     *   options?: object[] // Options for `select`
+     *   optionGroups?: object[] // Option groups for `select`
+     *   multiple?: boolean // For `select`
+     * }
+     * ```
+     */
+    filters: {
+        type: () => FilterType[];
+        default: () => never[];
+    };
+    /**
+     * The data representing applied filters. Each filter value is assigned
+     * to the `key` provided in the filter array definition.
+     *
+     * Use as `v-model:appliedFilters`.
+     *
+     * For example, if you defined two filters with keys "startDate" and "endDate" you
+     * would represent their current values using the following object:
+     *
+     * ```js
+     * {
+     *   startDate: null,
+     *   endDate: null
+     * }
+     * ```
+     */
+    appliedFilters: {
+        type: () => Record<string, any>;
+        default: () => {};
+    };
+    /**
+     * An optional array of shortcut filters which are added to the left
+     * of the query input.
+     *
+     * Each shortcut is represented as an ActionList.
+     *
+     * ```js
+     * interface Shortcut {
+     *   label: string
+     *   // See `ActionListItem` for more items options
+     *   items: Array<{
+     *     label: string
+     *     onAction(): void
+     *   }>
+     * }
+     * ```
+     */
+    shortcuts: {
+        type: () => FiltersShortcutType[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * The value to use in the query text field.
+     *
+     * Set this to `false` to disable querying.
+     */
+    query: {
+        type: PropType<string | null | false>;
+    };
+    /**
+     * The delay between emitting updated query values in milliseconds.
+     */
+    queryDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    mode: {
+        type: PropType<"single" | "multi">;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:appliedFilters"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:query"?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    filters: FilterType[];
+    mode: "single" | "multi";
+    appliedFilters: Record<string, any>;
+    queryDelay: number;
+}, {}, {
+    Button: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        type: {
+            type: PropType<import('../types').ActionTypeType>;
+            default: string;
+        };
+        icon: {
+            type: StringConstructor;
+        };
+        badge: {
+            type: PropType<string | number | import('../types').IconBadgeType>;
+        };
+        badgeStatus: {
+            type: PropType<import('../types').IconBadgeStatusType>;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        tooltip: {
+            type: StringConstructor;
+        };
+        tooltipPosition: {
+            type: PropType<import('../types').ActionTooltipPositionType>;
+            default: string;
+        };
+        dropdown: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        fullWidth: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+        url: {
+            type: StringConstructor;
+        };
+        external: {
+            type: BooleanConstructor;
+        };
+        invert: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        color: {
+            type: PropType<import('../types').ActionColorType>;
+        };
+        destructive: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        type: {
+            type: PropType<import('../types').ActionTypeType>;
+            default: string;
+        };
+        icon: {
+            type: StringConstructor;
+        };
+        badge: {
+            type: PropType<string | number | import('../types').IconBadgeType>;
+        };
+        badgeStatus: {
+            type: PropType<import('../types').IconBadgeStatusType>;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        tooltip: {
+            type: StringConstructor;
+        };
+        tooltipPosition: {
+            type: PropType<import('../types').ActionTooltipPositionType>;
+            default: string;
+        };
+        dropdown: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        fullWidth: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: StringConstructor;
+            default: string;
+        };
+        url: {
+            type: StringConstructor;
+        };
+        external: {
+            type: BooleanConstructor;
+        };
+        invert: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        color: {
+            type: PropType<import('../types').ActionColorType>;
+        };
+        destructive: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        disabled: boolean;
+        size: string;
+        type: import('../types').ActionTypeType;
+        destructive: boolean;
+        tooltipPosition: import('../types').ActionTooltipPositionType;
+        external: boolean;
+        dropdown: boolean;
+        fullWidth: boolean;
+        invert: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    FilterActions: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        filters: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        shortcuts: {
+            type: () => {
+                label: string;
+                items: any[];
+            }[];
+            default: () => never[];
+        };
+        mode: {
+            type: PropType<"single" | "multi">;
+            default: string;
+        };
+    }>, {}, {}, {}, {
+        $t: typeof import('../../utils/translate').translate;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        filters: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        shortcuts: {
+            type: () => {
+                label: string;
+                items: any[];
+            }[];
+            default: () => never[];
+        };
+        mode: {
+            type: PropType<"single" | "multi">;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        filters: unknown[];
+        mode: "single" | "multi";
+        shortcuts: {
+            label: string;
+            items: any[];
+        }[];
+    }, {}, {
+        ActionList: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../ActionList').ActionListProps> & Readonly<{
+                onShow?: (() => any) | undefined;
+                onHide?: (() => any) | undefined;
+                onClose?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                show: () => any;
+                hide: () => any;
+                close: () => any;
+            }, import('vue').PublicProps, {
+                placement: import('../Popper').PopperPlacementType;
+                items: ActionListItemType[];
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('../ActionList').ActionListProps> & Readonly<{
+                onShow?: (() => any) | undefined;
+                onHide?: (() => any) | undefined;
+                onClose?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, {
+                placement: import('../Popper').PopperPlacementType;
+                items: ActionListItemType[];
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('../ActionList').ActionListProps> & Readonly<{
+            onShow?: (() => any) | undefined;
+            onHide?: (() => any) | undefined;
+            onClose?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            show: () => any;
+            hide: () => any;
+            close: () => any;
+        }, string, {
+            placement: import('../Popper').PopperPlacementType;
+            items: ActionListItemType[];
+        }, {}, 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;
+            };
+        });
+        Button: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            type: {
+                type: PropType<import('../types').ActionTypeType>;
+                default: string;
+            };
+            icon: {
+                type: StringConstructor;
+            };
+            badge: {
+                type: PropType<string | number | import('../types').IconBadgeType>;
+            };
+            badgeStatus: {
+                type: PropType<import('../types').IconBadgeStatusType>;
+            };
+            disabled: {
+                type: BooleanConstructor;
+            };
+            tooltip: {
+                type: StringConstructor;
+            };
+            tooltipPosition: {
+                type: PropType<import('../types').ActionTooltipPositionType>;
+                default: string;
+            };
+            dropdown: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fullWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+            url: {
+                type: StringConstructor;
+            };
+            external: {
+                type: BooleanConstructor;
+            };
+            invert: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            color: {
+                type: PropType<import('../types').ActionColorType>;
+            };
+            destructive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            type: {
+                type: PropType<import('../types').ActionTypeType>;
+                default: string;
+            };
+            icon: {
+                type: StringConstructor;
+            };
+            badge: {
+                type: PropType<string | number | import('../types').IconBadgeType>;
+            };
+            badgeStatus: {
+                type: PropType<import('../types').IconBadgeStatusType>;
+            };
+            disabled: {
+                type: BooleanConstructor;
+            };
+            tooltip: {
+                type: StringConstructor;
+            };
+            tooltipPosition: {
+                type: PropType<import('../types').ActionTooltipPositionType>;
+                default: string;
+            };
+            dropdown: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fullWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+            url: {
+                type: StringConstructor;
+            };
+            external: {
+                type: BooleanConstructor;
+            };
+            invert: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            color: {
+                type: PropType<import('../types').ActionColorType>;
+            };
+            destructive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            size: string;
+            type: import('../types').ActionTypeType;
+            destructive: boolean;
+            tooltipPosition: import('../types').ActionTooltipPositionType;
+            external: boolean;
+            dropdown: boolean;
+            fullWidth: boolean;
+            invert: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ButtonGroup: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            segmented: {
+                type: BooleanConstructor;
+            };
+            fill: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            segmented: {
+                type: BooleanConstructor;
+            };
+            fill: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            fill: boolean;
+            segmented: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ButtonGroupItem: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    FilterItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        filter: {
+            type: () => FilterType;
+            required: true;
+        };
+        modelValue: {
+            type: null;
+        };
+    }>, {}, {}, {
+        hasEmptyValue(): boolean;
+        error(): string | null;
+    }, {
+        $t: typeof import('../../utils/translate').translate;
+        isDatePickerType: typeof import('../DatePicker').isDatePickerType;
+        updateValue(val: any): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        filter: {
+            type: () => FilterType;
+            required: true;
+        };
+        modelValue: {
+            type: null;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {
+        Button: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            type: {
+                type: PropType<import('../types').ActionTypeType>;
+                default: string;
+            };
+            icon: {
+                type: StringConstructor;
+            };
+            badge: {
+                type: PropType<string | number | import('../types').IconBadgeType>;
+            };
+            badgeStatus: {
+                type: PropType<import('../types').IconBadgeStatusType>;
+            };
+            disabled: {
+                type: BooleanConstructor;
+            };
+            tooltip: {
+                type: StringConstructor;
+            };
+            tooltipPosition: {
+                type: PropType<import('../types').ActionTooltipPositionType>;
+                default: string;
+            };
+            dropdown: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fullWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+            url: {
+                type: StringConstructor;
+            };
+            external: {
+                type: BooleanConstructor;
+            };
+            invert: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            color: {
+                type: PropType<import('../types').ActionColorType>;
+            };
+            destructive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            type: {
+                type: PropType<import('../types').ActionTypeType>;
+                default: string;
+            };
+            icon: {
+                type: StringConstructor;
+            };
+            badge: {
+                type: PropType<string | number | import('../types').IconBadgeType>;
+            };
+            badgeStatus: {
+                type: PropType<import('../types').IconBadgeStatusType>;
+            };
+            disabled: {
+                type: BooleanConstructor;
+            };
+            tooltip: {
+                type: StringConstructor;
+            };
+            tooltipPosition: {
+                type: PropType<import('../types').ActionTooltipPositionType>;
+                default: string;
+            };
+            dropdown: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fullWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: StringConstructor;
+                default: string;
+            };
+            url: {
+                type: StringConstructor;
+            };
+            external: {
+                type: BooleanConstructor;
+            };
+            invert: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            color: {
+                type: PropType<import('../types').ActionColorType>;
+            };
+            destructive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            size: string;
+            type: import('../types').ActionTypeType;
+            destructive: boolean;
+            tooltipPosition: import('../types').ActionTooltipPositionType;
+            external: boolean;
+            dropdown: boolean;
+            fullWidth: boolean;
+            invert: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        DatePicker: import('vue').DefineComponent<import('../DatePicker').DatePickerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            "update:modelValue": (v: string | null) => any;
+        }, string, import('vue').PublicProps, Readonly<import('../DatePicker').DatePickerProps> & Readonly<{
+            "onUpdate:modelValue"?: ((v: string | null) => any) | undefined;
+        }>, {
+            disabled: boolean;
+            type: "datetime" | "date" | "month" | "year";
+            autoOpen: boolean;
+            readonly: boolean;
+            modelFormat: string;
+            minTime: string;
+            maxTime: string;
+            clearable: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        TextField: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../TextField').TextFieldProps> & Readonly<{
+                onClick?: ((event: MouseEvent) => any) | undefined;
+                onBlur?: ((event: FocusEvent) => any) | undefined;
+                onFocus?: ((event: FocusEvent) => any) | undefined;
+                onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string | number | null, event?: Event | undefined) => any) | undefined;
+            }>, {
+                focus: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                click: (event: MouseEvent) => any;
+                blur: (event: FocusEvent) => any;
+                focus: (event: FocusEvent) => any;
+                keydown: (event: KeyboardEvent) => any;
+                "update:modelValue": (value: string | number | null, event?: Event | undefined) => any;
+            }, import('vue').PublicProps, {
+                type: "email" | "number" | "password" | "text" | "tel";
+                emptyValue: string | number | null;
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('../TextField').TextFieldProps> & Readonly<{
+                onClick?: ((event: MouseEvent) => any) | undefined;
+                onBlur?: ((event: FocusEvent) => any) | undefined;
+                onFocus?: ((event: FocusEvent) => any) | undefined;
+                onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string | number | null, event?: Event | undefined) => any) | undefined;
+            }>, {
+                focus: () => void;
+            }, {}, {}, {}, {
+                type: "email" | "number" | "password" | "text" | "tel";
+                emptyValue: string | number | null;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('../TextField').TextFieldProps> & Readonly<{
+            onClick?: ((event: MouseEvent) => any) | undefined;
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | number | null, event?: Event | undefined) => any) | undefined;
+        }>, {
+            focus: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            click: (event: MouseEvent) => any;
+            blur: (event: FocusEvent) => any;
+            focus: (event: FocusEvent) => any;
+            keydown: (event: KeyboardEvent) => any;
+            "update:modelValue": (value: string | number | null, event?: Event | undefined) => any;
+        }, string, {
+            type: "email" | "number" | "password" | "text" | "tel";
+            emptyValue: string | number | null;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                left?: (props: {}) => any;
+            } & {
+                prefix?: (props: {}) => any;
+            } & {
+                suffix?: (props: {}) => any;
+            } & {
+                right?: (props: {}) => any;
+            };
+        });
+        Select: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            label: {
+                type: PropType<string | false | null>;
+            };
+            error: {
+                type: PropType<string | false | null>;
+                required: false;
+            };
+            helpText: {
+                type: PropType<string | false | null>;
+            };
+            helpTextHtml: {
+                type: PropType<string | false | null>;
+            };
+            helpLink: {
+                type: PropType<string | false | null>;
+            };
+            modelValue: {
+                type: any;
+            };
+            emptyValue: {
+                type: null;
+                default: () => (null | undefined)[];
+            };
+            options: {
+                type: () => SelectOptionType[];
+                default: () => never[];
+            };
+            optionGroups: {
+                type: () => SelectOptionGroupType[];
+            };
+            placeholder: {
+                type: StringConstructor;
+                default: string;
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            noOptions: {
+                type: StringConstructor;
+            };
+            noResults: {
+                type: StringConstructor;
+            };
+            additionalOptions: {
+                type: StringConstructor;
+            };
+            tags: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showDescription: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            filterFn: {
+                type: FunctionConstructor;
+                default: null;
+            };
+            fuzzy: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            searchable: {
+                type: (BooleanConstructor | StringConstructor)[];
+                default: string;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            clearable: {
+                type: (BooleanConstructor | StringConstructor)[];
+                default: string;
+            };
+            toggleAll: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dropdownMinWidth: {
+                type: StringConstructor;
+                default: string;
+            };
+            teleport: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dragSelect: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            style: Record<string, string>;
+        }, {
+            didJustFocusSearch: boolean;
+            isSearchFocused: boolean;
+            findText: string;
+            findTextTimeout: any | null;
+            onDocClick: any;
+            popper: import('../../utils/positionPanel').PanelPosition | null;
+            isOpen: boolean;
+            teleportId: string;
+            searchText: string;
+            selected: any | any[] | null;
+            popperPlacement: string;
+            activeIndex: number;
+            prevSelected: Set<unknown>;
+            controlWidth: null | number;
+            resizeObserver: null | ResizeObserver;
+            dragOrigin: {
+                x: number;
+                y: number;
+            } | null;
+            isDragArmed: boolean;
+            openedByPress: boolean;
+            ignoreNextDocClick: boolean;
+        }, {
+            popperPlacementSide(): string;
+            dropdownStyle(): string;
+            hasInvalidValue(): false;
+            displayText(): any;
+            selectedMap(): any;
+            isEmpty(): boolean;
+            resolvedOptions(): any;
+            resolvedOptionGroups(): SelectOptionGroupType[];
+            selectedOptions(): any;
+            activeFilterFn(): (searchText: string, options: any[], group?: any) => any[];
+            filteredGroups(): any;
+            filteredOptions(): any;
+            numCurrentOptions(): any;
+            showSearch(): boolean;
+            canClear(): boolean;
+            toggleAllState(): {
+                checked: boolean;
+                indeterminate: boolean;
+            };
+        }, {
+            onControlMousedown(event: MouseEvent): void;
+            onControlClick(event: MouseEvent): void;
+            onDragMove(event: MouseEvent): void;
+            onDragEnd(event: MouseEvent): void;
+            endDragTracking(): void;
+            optionAtPoint(x: number, y: number): any;
+            onBlur(): void;
+            focus(): void;
+            searchFocus(): void;
+            searchBlur(): void;
+            onKeydown(event: KeyboardEvent): void;
+            findOption(predicate: any): any;
+            findOptionWithLabelStart(label: any): any;
+            scrollActiveOptionIntoView(): void;
+            open(): void;
+            close(): void;
+            destroyPopper(): void;
+            updatePopper(): void;
+            clearSelected(): void;
+            setDocClickHandler(doAdd: any): void;
+            getOptionState(option: any): boolean;
+            toggleOption(option: any): void;
+            toggleAllOptions(): void;
+            emitChange(selected: any | any[]): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            label: {
+                type: PropType<string | false | null>;
+            };
+            error: {
+                type: PropType<string | false | null>;
+                required: false;
+            };
+            helpText: {
+                type: PropType<string | false | null>;
+            };
+            helpTextHtml: {
+                type: PropType<string | false | null>;
+            };
+            helpLink: {
+                type: PropType<string | false | null>;
+            };
+            modelValue: {
+                type: any;
+            };
+            emptyValue: {
+                type: null;
+                default: () => (null | undefined)[];
+            };
+            options: {
+                type: () => SelectOptionType[];
+                default: () => never[];
+            };
+            optionGroups: {
+                type: () => SelectOptionGroupType[];
+            };
+            placeholder: {
+                type: StringConstructor;
+                default: string;
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            noOptions: {
+                type: StringConstructor;
+            };
+            noResults: {
+                type: StringConstructor;
+            };
+            additionalOptions: {
+                type: StringConstructor;
+            };
+            tags: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            showDescription: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            filterFn: {
+                type: FunctionConstructor;
+                default: null;
+            };
+            fuzzy: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            searchable: {
+                type: (BooleanConstructor | StringConstructor)[];
+                default: string;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            clearable: {
+                type: (BooleanConstructor | StringConstructor)[];
+                default: string;
+            };
+            toggleAll: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dropdownMinWidth: {
+                type: StringConstructor;
+                default: string;
+            };
+            teleport: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dragSelect: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onChange?: ((...args: any[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            disabled: boolean;
+            loading: boolean;
+            modelValue: any;
+            placeholder: string;
+            readonly: boolean;
+            emptyValue: any;
+            multiple: boolean;
+            options: SelectOptionType[];
+            clearable: string | boolean;
+            teleport: boolean;
+            tags: boolean;
+            showDescription: boolean;
+            filterFn: Function;
+            fuzzy: boolean;
+            searchable: string | boolean;
+            toggleAll: boolean;
+            dropdownMinWidth: string;
+            dragSelect: boolean;
+        }, {}, {
+            Icon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                icon: {
+                    type: StringConstructor;
+                };
+                size: {
+                    type: StringConstructor;
+                };
+                contained: {
+                    type: BooleanConstructor;
+                };
+                badge: {
+                    type: PropType<import('../types').IconBadgeStatusType>;
+                };
+                badgeIcon: {
+                    type: StringConstructor;
+                };
+                badgeColor: {
+                    type: StringConstructor;
+                };
+            }>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                icon: {
+                    type: StringConstructor;
+                };
+                size: {
+                    type: StringConstructor;
+                };
+                contained: {
+                    type: BooleanConstructor;
+                };
+                badge: {
+                    type: PropType<import('../types').IconBadgeStatusType>;
+                };
+                badgeIcon: {
+                    type: StringConstructor;
+                };
+                badgeColor: {
+                    type: StringConstructor;
+                };
+            }>> & Readonly<{}>, {
+                contained: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ScrollPane: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../ScrollPane').ScrollPaneProps> & Readonly<{}>, {
+                    scrollTo: (x: number, y: number) => void;
+                    update: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                    disabled: boolean;
+                    contain: boolean;
+                    direction: import('../ScrollPane').ScrollPaneDirectionType;
+                    indicators: boolean;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('../ScrollPane').ScrollPaneProps> & Readonly<{}>, {
+                    scrollTo: (x: number, y: number) => void;
+                    update: () => void;
+                }, {}, {}, {}, {
+                    disabled: boolean;
+                    contain: boolean;
+                    direction: import('../ScrollPane').ScrollPaneDirectionType;
+                    indicators: boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('../ScrollPane').ScrollPaneProps> & Readonly<{}>, {
+                scrollTo: (x: number, y: number) => void;
+                update: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                disabled: boolean;
+                contain: boolean;
+                direction: import('../ScrollPane').ScrollPaneDirectionType;
+                indicators: 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;
+                };
+            });
+            Labelled: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                label: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                error: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                helpText: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                helpTextHtml: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                helpLink: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                required: {
+                    type: BooleanConstructor;
+                    required: false;
+                };
+            }>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                label: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                error: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                helpText: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                helpTextHtml: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                helpLink: {
+                    type: PropType<string | false | null>;
+                    required: false;
+                };
+                required: {
+                    type: BooleanConstructor;
+                    required: false;
+                };
+            }>> & Readonly<{}>, {
+                required: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            Tag: {
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../Tag/Tag.vue').TagProps> & Readonly<{
+                    onRemove?: (() => any) | undefined;
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                    remove: () => any;
+                }, import('vue').PublicProps, {
+                    tooltipPosition: import('../Popper').PopperPlacementType;
+                    required: boolean;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('../Tag/Tag.vue').TagProps> & Readonly<{
+                    onRemove?: (() => any) | undefined;
+                }>, {}, {}, {}, {}, {
+                    tooltipPosition: import('../Popper').PopperPlacementType;
+                    required: boolean;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('../Tag/Tag.vue').TagProps> & Readonly<{
+                onRemove?: (() => any) | undefined;
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                remove: () => any;
+            }, string, {
+                tooltipPosition: import('../Popper').PopperPlacementType;
+                required: 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;
+                };
+            });
+            CheckboxControl: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                };
+                checked: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                indeterminate: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                };
+                checked: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                indeterminate: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                error: boolean;
+                readonly: boolean;
+                checked: boolean;
+                indeterminate: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            Spinner: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                color: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                color: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                size: string;
+                color: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            MaybeMountingPortal: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                teleport: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                mountTo: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                defer: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                teleport: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                mountTo: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                defer: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                defer: boolean;
+                teleport: boolean;
+                mountTo: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    Icon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        icon: {
+            type: StringConstructor;
+        };
+        size: {
+            type: StringConstructor;
+        };
+        contained: {
+            type: BooleanConstructor;
+        };
+        badge: {
+            type: PropType<import('../types').IconBadgeStatusType>;
+        };
+        badgeIcon: {
+            type: StringConstructor;
+        };
+        badgeColor: {
+            type: StringConstructor;
+        };
+    }>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        icon: {
+            type: StringConstructor;
+        };
+        size: {
+            type: StringConstructor;
+        };
+        contained: {
+            type: BooleanConstructor;
+        };
+        badge: {
+            type: PropType<import('../types').IconBadgeStatusType>;
+        };
+        badgeIcon: {
+            type: StringConstructor;
+        };
+        badgeColor: {
+            type: StringConstructor;
+        };
+    }>> & Readonly<{}>, {
+        contained: boolean;
+    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    Tag: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../Tag/Tag.vue').TagProps> & Readonly<{
+            onRemove?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            remove: () => any;
+        }, import('vue').PublicProps, {
+            tooltipPosition: import('../Popper').PopperPlacementType;
+            required: boolean;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('../Tag/Tag.vue').TagProps> & Readonly<{
+            onRemove?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            tooltipPosition: import('../Popper').PopperPlacementType;
+            required: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('../Tag/Tag.vue').TagProps> & Readonly<{
+        onRemove?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        remove: () => any;
+    }, string, {
+        tooltipPosition: import('../Popper').PopperPlacementType;
+        required: 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;
+        };
+    });
+    TextField: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../TextField').TextFieldProps> & Readonly<{
+            onClick?: ((event: MouseEvent) => any) | undefined;
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | number | null, event?: Event | undefined) => any) | undefined;
+        }>, {
+            focus: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            click: (event: MouseEvent) => any;
+            blur: (event: FocusEvent) => any;
+            focus: (event: FocusEvent) => any;
+            keydown: (event: KeyboardEvent) => any;
+            "update:modelValue": (value: string | number | null, event?: Event | undefined) => any;
+        }, import('vue').PublicProps, {
+            type: "email" | "number" | "password" | "text" | "tel";
+            emptyValue: string | number | null;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('../TextField').TextFieldProps> & Readonly<{
+            onClick?: ((event: MouseEvent) => any) | undefined;
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | number | null, event?: Event | undefined) => any) | undefined;
+        }>, {
+            focus: () => void;
+        }, {}, {}, {}, {
+            type: "email" | "number" | "password" | "text" | "tel";
+            emptyValue: string | number | null;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('../TextField').TextFieldProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number | null, event?: Event | undefined) => any) | undefined;
+    }>, {
+        focus: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        click: (event: MouseEvent) => any;
+        blur: (event: FocusEvent) => any;
+        focus: (event: FocusEvent) => any;
+        keydown: (event: KeyboardEvent) => any;
+        "update:modelValue": (value: string | number | null, event?: Event | undefined) => any;
+    }, string, {
+        type: "email" | "number" | "password" | "text" | "tel";
+        emptyValue: string | number | null;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            left?: (props: {}) => any;
+        } & {
+            prefix?: (props: {}) => any;
+        } & {
+            suffix?: (props: {}) => any;
+        } & {
+            right?: (props: {}) => any;
+        };
+    });
+    Sheet: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../Sheet').SheetProps> & Readonly<{
+            onClose?: (() => any) | undefined;
+            onUpdate?: ((v: boolean) => any) | undefined;
+            "onBefore-open"?: (() => any) | undefined;
+            "onAfter-open"?: (() => any) | undefined;
+            "onBefore-close"?: (() => any) | undefined;
+            "onAfter-close"?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            close: () => any;
+            update: (v: boolean) => any;
+            "before-open": () => any;
+            "after-open": () => any;
+            "before-close": () => any;
+            "after-close": () => any;
+        }, import('vue').PublicProps, {
+            visible: boolean;
+            size: number;
+            loading: boolean;
+            peek: number;
+            edge: import('../Sheet').SheetEdgeType;
+            animateInDuration: number;
+            animateOutDuration: number;
+            minIndex: number;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('../Sheet').SheetProps> & Readonly<{
+            onClose?: (() => any) | undefined;
+            onUpdate?: ((v: boolean) => any) | undefined;
+            "onBefore-open"?: (() => any) | undefined;
+            "onAfter-open"?: (() => any) | undefined;
+            "onBefore-close"?: (() => any) | undefined;
+            "onAfter-close"?: (() => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            visible: boolean;
+            size: number;
+            loading: boolean;
+            peek: number;
+            edge: import('../Sheet').SheetEdgeType;
+            animateInDuration: number;
+            animateOutDuration: number;
+            minIndex: number;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('../Sheet').SheetProps> & Readonly<{
+        onClose?: (() => any) | undefined;
+        onUpdate?: ((v: boolean) => any) | undefined;
+        "onBefore-open"?: (() => any) | undefined;
+        "onAfter-open"?: (() => any) | undefined;
+        "onBefore-close"?: (() => any) | undefined;
+        "onAfter-close"?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        close: () => any;
+        update: (v: boolean) => any;
+        "before-open": () => any;
+        "after-open": () => any;
+        "before-close": () => any;
+        "after-close": () => any;
+    }, string, {
+        visible: boolean;
+        size: number;
+        loading: boolean;
+        peek: number;
+        edge: import('../Sheet').SheetEdgeType;
+        animateInDuration: number;
+        animateOutDuration: number;
+        minIndex: number;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            external?: (props: {}) => any;
+        } & {
+            actions?: (props: {}) => any;
+        } & {
+            default?: (props: {}) => any;
+        };
+    });
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;