import { ComputedRef, PropType, Ref } from 'vue';
import { ColorScheme, LabelValue } from '../../declaration';
import { VsTableStyleSet, TableHeader, TableRow, TableFilter, SortType } from './types';
import { SortableEvent } from 'sortablejs';
declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    colorScheme: {
        type: PropType<ColorScheme>;
    };
    styleSet: {
        type: PropType<string | VsTableStyleSet>;
        default: string;
    };
    dense: {
        type: BooleanConstructor;
        default: boolean;
    };
    draggable: {
        type: BooleanConstructor;
        default: boolean;
    };
    filter: {
        type: PropType<TableFilter>;
        default: null;
    };
    headers: {
        type: PropType<TableHeader[]>;
        required: true;
    };
    items: {
        type: PropType<any[]>;
        default: () => any[];
        required: true;
    };
    rows: {
        type: PropType<TableRow>;
        default: () => {};
    };
    responsive: {
        type: BooleanConstructor;
        default: boolean;
    };
    loading: {
        type: BooleanConstructor;
        default: boolean;
    };
    pagination: {
        type: BooleanConstructor;
        default: boolean;
    };
    paginationOptions: {
        type: PropType<LabelValue<number>[]>;
        default: () => LabelValue<number>[];
    };
    pageEdgeButtons: {
        type: BooleanConstructor;
        default: boolean;
    };
    primary: {
        type: BooleanConstructor;
        default: boolean;
    };
    search: {
        type: BooleanConstructor;
        default: boolean;
    };
    searchPlaceholder: {
        type: StringConstructor;
        default: string;
    };
    searchText: {
        type: StringConstructor;
        default: string;
    };
    searchableKeys: {
        type: PropType<string[]>;
        default: () => string[];
    };
    selectable: {
        type: BooleanConstructor;
        default: boolean;
    };
    totalLength: {
        type: NumberConstructor;
    };
    itemsPerPage: {
        type: NumberConstructor;
        default: number;
    };
    page: {
        type: NumberConstructor;
        default: number;
    };
    pagedItems: {
        type: PropType<any[]>;
        default: () => any[];
    };
    selectedItems: {
        type: PropType<any[]>;
        default: () => any[];
    };
    totalItems: {
        type: PropType<any[]>;
        default: () => any[];
    };
    width: {
        type: PropType<string | number | import('../../declaration').Breakpoints>;
        default: null;
    };
    grid: {
        type: PropType<string | number | import('../../declaration').Breakpoints>;
        default: null;
    };
}>, {
    computedColorScheme: ComputedRef<"none" | "gray" | "red" | "orange" | "yellow" | "yellow-green" | "green" | "teal" | "light-blue" | "blue" | "indigo" | "purple" | "pink" | "brown">;
    colorSchemeClass: ComputedRef<string>;
    computedStyleSet: ComputedRef<{
        [key: string]: any;
    }>;
    plainStyleSet: ComputedRef<VsTableStyleSet>;
    computedSearchText: ComputedRef<string>;
    headerSlots: ComputedRef<{
        [key: string]: any;
    }>;
    itemSlots: ComputedRef<{
        [key: string]: any;
    }>;
    trStyle: ComputedRef<{
        [key: string]: any;
    }>;
    sortTypes: Ref<{
        [key: string]: SortType;
    }, {
        [key: string]: SortType;
    }>;
    hasExpand: ComputedRef<boolean>;
    isSelectedAll: Ref<boolean, boolean>;
    isIndeterminate: Ref<boolean, boolean>;
    utils: {
        clipboard: {
            copy(text: string): void;
        };
        device: {
            isTouchDevice: () => boolean;
        };
        dom: {
            isBrowser(): boolean;
            getClientRect(element: HTMLElement): DOMRect;
        };
        log: {
            error(target: string, message: string): void;
            warning(target: string, message: string): void;
            propError(componentName: string, property: string, message: string): void;
            propWarning(componentName: string, property: string, message: string): void;
        };
        function: {
            debounce(func: (...args: any) => any, delay?: number): (...args: any) => any;
            throttle(func: (...args: any) => any, interval?: number): (...args: any) => any;
        };
        object: {
            get: <TDefault = unknown>(value: any, path: string, defaultValue?: TDefault | undefined) => TDefault;
            isEqual: <TType>(x: TType, y: TType) => boolean;
            isArray: (arg: any) => arg is any[];
            unique: <T, K extends string | number | symbol>(array: readonly T[], toKey?: ((item: T) => K) | undefined) => T[];
            isUniq(array: any[]): boolean;
            isPlainObject(value: any): value is Record<string, any>;
            omit: <T, TKeys extends keyof T>(obj: T, keys: TKeys[]) => Omit<T, TKeys>;
            pick: <T extends object, TKeys extends keyof T>(obj: T, keys: TKeys[]) => Pick<T, TKeys>;
            pickWithPath(object: Record<string, any>, keys: string[]): Pick<string, any>;
            shake: <RemovedKeys extends string, T>(obj: T, filter?: (value: any) => boolean) => Omit<T, RemovedKeys>;
        };
        props: {
            checkPropExist<T = any>(componentName: string, property: string, options: any, value: T): boolean;
            checkValidNumber(componentName: string, property: string, value: number | string): boolean;
        };
        string: {
            createID(size?: number): string;
            pascalToKebab(str: string): string;
            convertToString(value: any): string;
            convertToStringSize(size: string | number): string;
            toFileSizeFormat(number: number | undefined | null): string;
        };
    };
    innerSearchText: Ref<string, string>;
    updateInnerSearchText: (text: string) => void;
    innerPage: Ref<number, number>;
    innerItemsPerPage: Ref<number, number>;
    paginationLength: ComputedRef<number>;
    totalItemsLength: Ref<number, number>;
    canDrag: ComputedRef<boolean>;
    hasSelectable: ComputedRef<boolean>;
    onToggleCheck: (check: boolean) => void;
    onChangeSelectedItems: (selectedItems: any[]) => void;
    emitPagedItems: (items: any[]) => void;
    emitTotalItems: (items: any[]) => void;
    emitClickRow: (rowItem: any, rowIndex: number) => void;
    emitDrag: (evt: SortableEvent) => void;
    expand: (index: number) => any;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("drag" | "update" | "clickRow" | "update:itemsPerPage" | "update:page" | "update:pagedItems" | "update:selectedItems" | "update:totalItems")[], "drag" | "update" | "clickRow" | "update:itemsPerPage" | "update:page" | "update:pagedItems" | "update:selectedItems" | "update:totalItems", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    colorScheme: {
        type: PropType<ColorScheme>;
    };
    styleSet: {
        type: PropType<string | VsTableStyleSet>;
        default: string;
    };
    dense: {
        type: BooleanConstructor;
        default: boolean;
    };
    draggable: {
        type: BooleanConstructor;
        default: boolean;
    };
    filter: {
        type: PropType<TableFilter>;
        default: null;
    };
    headers: {
        type: PropType<TableHeader[]>;
        required: true;
    };
    items: {
        type: PropType<any[]>;
        default: () => any[];
        required: true;
    };
    rows: {
        type: PropType<TableRow>;
        default: () => {};
    };
    responsive: {
        type: BooleanConstructor;
        default: boolean;
    };
    loading: {
        type: BooleanConstructor;
        default: boolean;
    };
    pagination: {
        type: BooleanConstructor;
        default: boolean;
    };
    paginationOptions: {
        type: PropType<LabelValue<number>[]>;
        default: () => LabelValue<number>[];
    };
    pageEdgeButtons: {
        type: BooleanConstructor;
        default: boolean;
    };
    primary: {
        type: BooleanConstructor;
        default: boolean;
    };
    search: {
        type: BooleanConstructor;
        default: boolean;
    };
    searchPlaceholder: {
        type: StringConstructor;
        default: string;
    };
    searchText: {
        type: StringConstructor;
        default: string;
    };
    searchableKeys: {
        type: PropType<string[]>;
        default: () => string[];
    };
    selectable: {
        type: BooleanConstructor;
        default: boolean;
    };
    totalLength: {
        type: NumberConstructor;
    };
    itemsPerPage: {
        type: NumberConstructor;
        default: number;
    };
    page: {
        type: NumberConstructor;
        default: number;
    };
    pagedItems: {
        type: PropType<any[]>;
        default: () => any[];
    };
    selectedItems: {
        type: PropType<any[]>;
        default: () => any[];
    };
    totalItems: {
        type: PropType<any[]>;
        default: () => any[];
    };
    width: {
        type: PropType<string | number | import('../../declaration').Breakpoints>;
        default: null;
    };
    grid: {
        type: PropType<string | number | import('../../declaration').Breakpoints>;
        default: null;
    };
}>> & Readonly<{
    onDrag?: ((...args: any[]) => any) | undefined;
    onClickRow?: ((...args: any[]) => any) | undefined;
    onUpdate?: ((...args: any[]) => any) | undefined;
    "onUpdate:itemsPerPage"?: ((...args: any[]) => any) | undefined;
    "onUpdate:page"?: ((...args: any[]) => any) | undefined;
    "onUpdate:pagedItems"?: ((...args: any[]) => any) | undefined;
    "onUpdate:selectedItems"?: ((...args: any[]) => any) | undefined;
    "onUpdate:totalItems"?: ((...args: any[]) => any) | undefined;
}>, {
    search: boolean;
    width: string | number | import('../../declaration').Breakpoints;
    filter: TableFilter;
    dense: boolean;
    grid: string | number | import('../../declaration').Breakpoints;
    styleSet: string | VsTableStyleSet;
    loading: boolean;
    primary: boolean;
    responsive: boolean;
    page: number;
    selectable: boolean;
    draggable: boolean;
    searchPlaceholder: string;
    rows: TableRow<any>;
    items: any[];
    pagination: boolean;
    searchText: string;
    searchableKeys: string[];
    selectedItems: any[];
    paginationOptions: LabelValue<number>[];
    pageEdgeButtons: boolean;
    itemsPerPage: number;
    pagedItems: any[];
    totalItems: any[];
}, {}, {
    VsResponsive: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        tag: {
            type: StringConstructor;
            default: string;
        };
        width: {
            type: PropType<string | number | import('../../declaration').Breakpoints>;
            default: null;
        };
        grid: {
            type: PropType<string | number | import('../../declaration').Breakpoints>;
            default: null;
        };
    }>, {
        responsiveClasses: ComputedRef<string[]>;
        responsiveStyles: ComputedRef<Record<string, string>>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        tag: {
            type: StringConstructor;
            default: string;
        };
        width: {
            type: PropType<string | number | import('../../declaration').Breakpoints>;
            default: null;
        };
        grid: {
            type: PropType<string | number | import('../../declaration').Breakpoints>;
            default: null;
        };
    }>> & Readonly<{}>, {
        width: string | number | import('../../declaration').Breakpoints;
        tag: string;
        grid: string | number | import('../../declaration').Breakpoints;
    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    VsTableHeader: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        headers: {
            type: PropType<TableHeader[]>;
            required: true;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        expandable: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        search: {
            type: BooleanConstructor;
            default: boolean;
        };
        searchPlaceholder: {
            type: StringConstructor;
            default: string;
        };
        selectable: {
            type: BooleanConstructor;
            default: boolean;
        };
        trStyle: {
            type: PropType<{
                [key: string]: any;
            }>;
            default: () => {};
        };
        sortTypes: {
            type: PropType<{
                [key: string]: SortType;
            }>;
            default: () => {};
        };
    }>, {
        updateSortTypes: ({ key, sortable }: TableHeader) => void;
        getSortIcon: (type: SortType) => "expandMore" | "expandLess" | "unfoldMore";
        emitSearchText: (searchText: string) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update:sortTypes" | "change:searchText")[], "update:sortTypes" | "change:searchText", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        headers: {
            type: PropType<TableHeader[]>;
            required: true;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        expandable: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        search: {
            type: BooleanConstructor;
            default: boolean;
        };
        searchPlaceholder: {
            type: StringConstructor;
            default: string;
        };
        selectable: {
            type: BooleanConstructor;
            default: boolean;
        };
        trStyle: {
            type: PropType<{
                [key: string]: any;
            }>;
            default: () => {};
        };
        sortTypes: {
            type: PropType<{
                [key: string]: SortType;
            }>;
            default: () => {};
        };
    }>> & Readonly<{
        "onUpdate:sortTypes"?: ((...args: any[]) => any) | undefined;
        "onChange:searchText"?: ((...args: any[]) => any) | undefined;
    }>, {
        search: boolean;
        loading: boolean;
        selectable: boolean;
        draggable: boolean;
        expandable: boolean;
        searchPlaceholder: string;
        trStyle: {
            [key: string]: any;
        };
        sortTypes: {
            [key: string]: SortType;
        };
    }, {}, {
        VsIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            icon: {
                type: PropType<keyof typeof import('../..').iconSvgs>;
                required: true;
            };
            size: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
            };
        }>, {
            iconSvgs: {
                attachFile: string;
                check: string;
                close: string;
                copy: string;
                drag: string;
                error: string;
                expandLess: string;
                expandMore: string;
                goFirst: string;
                goLast: string;
                goNext: string;
                goPrev: string;
                info: string;
                link: string;
                keyboardArrowUp: string;
                keyboardArrowDown: string;
                menu: string;
                message: string;
                noData: string;
                radioChecked: string;
                radioUnchecked: string;
                rotateRight: string;
                search: string;
                success: string;
                themeDark: string;
                themeLight: string;
                unfoldMore: string;
                warning: string;
            };
            computedSize: ComputedRef<{
                width?: undefined;
                height?: undefined;
            } | {
                width: string;
                height: string;
            }>;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            icon: {
                type: PropType<keyof typeof import('../..').iconSvgs>;
                required: true;
            };
            size: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
            };
        }>> & Readonly<{}>, {
            size: string | number;
        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        VsInput: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            styleSet: {
                type: PropType<string | import('..').VsInputStyleSet>;
            };
            autocomplete: {
                type: BooleanConstructor;
                default: boolean;
            };
            max: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
                validator: (value: number | string) => boolean;
            };
            min: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
                validator: (value: number | string) => boolean;
            };
            type: {
                type: PropType<import('..').InputType>;
                default: string;
            };
            modelValue: {
                type: PropType<import('../vs-input/types').InputValueType>;
                default: null;
            };
            modelModifiers: {
                type: PropType<import('../../declaration').StringModifiers>;
                default: () => {};
            };
            width: {
                type: PropType<string | number | import('../../declaration').Breakpoints>;
                default: null;
            };
            grid: {
                type: PropType<string | number | import('../../declaration').Breakpoints>;
                default: null;
            };
            required: {
                type: BooleanConstructor;
                default: boolean;
            };
            name: {
                type: StringConstructor;
                default: string;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            messages: {
                type: PropType<import('../../declaration').Message<import('../vs-input/types').InputValueType>[]>;
                default: () => import('../../declaration').Message<import('../vs-input/types').InputValueType>[];
            };
            rules: {
                type: PropType<import('../../declaration').Rule<import('../vs-input/types').InputValueType>[]>;
                default: () => import('../../declaration').Rule<import('../vs-input/types').InputValueType>[];
            };
            noDefaultRules: {
                type: BooleanConstructor;
                default: boolean;
            };
            state: {
                type: PropType<import('../../declaration').UIState>;
                default: import('../../declaration').UIState;
            };
            ariaLabel: {
                type: StringConstructor;
                default: null;
            };
            dense: {
                type: BooleanConstructor;
                default: boolean;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            noMessage: {
                type: BooleanConstructor;
                default: boolean;
            };
            placeholder: {
                type: StringConstructor;
                default: string;
            };
            visible: {
                type: BooleanConstructor;
                default: boolean;
            };
            changed: {
                type: BooleanConstructor;
                default: boolean;
            };
            valid: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            computedId: ComputedRef<string>;
            classObj: ComputedRef<{
                'vs-dense': boolean;
                'vs-disabled': boolean;
                'vs-readonly': boolean;
            }>;
            colorSchemeClass: ComputedRef<string>;
            computedStyleSet: ComputedRef<{
                [key: string]: any;
            }>;
            inputValue: Ref<import('../vs-input/types').InputValueType, import('../vs-input/types').InputValueType>;
            updateValue: (event: Event) => void;
            inputRef: Ref<HTMLInputElement | null, HTMLInputElement | null>;
            computedMessages: ComputedRef<import('../../declaration').StateMessage<import('../../declaration').UIState>[]>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            shake: Ref<boolean, boolean>;
            focus: () => void;
            blur: () => void;
            select: () => void;
            clear: () => void;
            validate: () => boolean;
            onFocus: (e: FocusEvent) => void;
            onBlur: (e: FocusEvent) => void;
            onEnter: (e: KeyboardEvent) => void;
            clearWithFocus: () => void;
            stateClasses: ComputedRef<{
                [x: string]: boolean;
                'vs-state-box': boolean;
            }>;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("blur" | "change" | "focus" | "update:modelValue" | "update:valid" | "update:changed" | "enter" | "prepend" | "append")[], "blur" | "change" | "focus" | "update:modelValue" | "update:valid" | "update:changed" | "enter" | "prepend" | "append", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            styleSet: {
                type: PropType<string | import('..').VsInputStyleSet>;
            };
            autocomplete: {
                type: BooleanConstructor;
                default: boolean;
            };
            max: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
                validator: (value: number | string) => boolean;
            };
            min: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
                validator: (value: number | string) => boolean;
            };
            type: {
                type: PropType<import('..').InputType>;
                default: string;
            };
            modelValue: {
                type: PropType<import('../vs-input/types').InputValueType>;
                default: null;
            };
            modelModifiers: {
                type: PropType<import('../../declaration').StringModifiers>;
                default: () => {};
            };
            width: {
                type: PropType<string | number | import('../../declaration').Breakpoints>;
                default: null;
            };
            grid: {
                type: PropType<string | number | import('../../declaration').Breakpoints>;
                default: null;
            };
            required: {
                type: BooleanConstructor;
                default: boolean;
            };
            name: {
                type: StringConstructor;
                default: string;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            messages: {
                type: PropType<import('../../declaration').Message<import('../vs-input/types').InputValueType>[]>;
                default: () => import('../../declaration').Message<import('../vs-input/types').InputValueType>[];
            };
            rules: {
                type: PropType<import('../../declaration').Rule<import('../vs-input/types').InputValueType>[]>;
                default: () => import('../../declaration').Rule<import('../vs-input/types').InputValueType>[];
            };
            noDefaultRules: {
                type: BooleanConstructor;
                default: boolean;
            };
            state: {
                type: PropType<import('../../declaration').UIState>;
                default: import('../../declaration').UIState;
            };
            ariaLabel: {
                type: StringConstructor;
                default: null;
            };
            dense: {
                type: BooleanConstructor;
                default: boolean;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            noMessage: {
                type: BooleanConstructor;
                default: boolean;
            };
            placeholder: {
                type: StringConstructor;
                default: string;
            };
            visible: {
                type: BooleanConstructor;
                default: boolean;
            };
            changed: {
                type: BooleanConstructor;
                default: boolean;
            };
            valid: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            onFocus?: ((...args: any[]) => any) | undefined;
            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
            "onUpdate:valid"?: ((...args: any[]) => any) | undefined;
            "onUpdate:changed"?: ((...args: any[]) => any) | undefined;
            onEnter?: ((...args: any[]) => any) | undefined;
            onPrepend?: ((...args: any[]) => any) | undefined;
            onAppend?: ((...args: any[]) => any) | undefined;
        }>, {
            width: string | number | import('../../declaration').Breakpoints;
            required: boolean;
            name: string;
            type: import('..').InputType;
            label: string;
            disabled: boolean;
            readonly: boolean;
            modelValue: import('../vs-input/types').InputValueType;
            id: string;
            messages: import('../../declaration').Message<import('../vs-input/types').InputValueType>[];
            rules: import('../../declaration').Rule<import('../vs-input/types').InputValueType>[];
            noDefaultRules: boolean;
            state: import('../../declaration').UIState;
            ariaLabel: string;
            dense: boolean;
            noClear: boolean;
            noMessage: boolean;
            placeholder: string;
            visible: boolean;
            changed: boolean;
            valid: boolean;
            grid: string | number | import('../../declaration').Breakpoints;
            max: string | number;
            min: string | number;
            autocomplete: boolean;
            modelModifiers: import('../../declaration').StringModifiers;
        }, {}, {
            VsInputWrapper: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                dense: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                id: {
                    type: StringConstructor;
                    default: string;
                };
                label: {
                    type: StringConstructor;
                    default: string;
                };
                messages: {
                    type: PropType<import('../../declaration').StateMessage[]>;
                    default: () => never[];
                };
                noMessage: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                required: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | import('../../declaration').Breakpoints>;
                    default: null;
                };
                grid: {
                    type: PropType<string | number | import('../../declaration').Breakpoints>;
                    default: null;
                };
            }>, {
                colorSchemeClass: ComputedRef<string>;
                needToShake: Ref<boolean, boolean>;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                dense: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                id: {
                    type: StringConstructor;
                    default: string;
                };
                label: {
                    type: StringConstructor;
                    default: string;
                };
                messages: {
                    type: PropType<import('../../declaration').StateMessage[]>;
                    default: () => never[];
                };
                noMessage: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                required: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | import('../../declaration').Breakpoints>;
                    default: null;
                };
                grid: {
                    type: PropType<string | number | import('../../declaration').Breakpoints>;
                    default: null;
                };
            }>> & Readonly<{}>, {
                width: string | number | import('../../declaration').Breakpoints;
                required: boolean;
                label: string;
                disabled: boolean;
                id: string;
                messages: import('../../declaration').StateMessage<import('../../declaration').UIState>[];
                dense: boolean;
                noMessage: boolean;
                grid: string | number | import('../../declaration').Breakpoints;
                groupLabel: boolean;
                shake: boolean;
            }, {}, {
                VsResponsive: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | import('../../declaration').Breakpoints>;
                        default: null;
                    };
                    grid: {
                        type: PropType<string | number | import('../../declaration').Breakpoints>;
                        default: null;
                    };
                }>, {
                    responsiveClasses: ComputedRef<string[]>;
                    responsiveStyles: ComputedRef<Record<string, string>>;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | import('../../declaration').Breakpoints>;
                        default: null;
                    };
                    grid: {
                        type: PropType<string | number | import('../../declaration').Breakpoints>;
                        default: null;
                    };
                }>> & Readonly<{}>, {
                    width: string | number | import('../../declaration').Breakpoints;
                    tag: string;
                    grid: string | number | import('../../declaration').Breakpoints;
                }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
                VsMessage: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                    dense: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    message: {
                        type: PropType<import('../../declaration').StateMessage>;
                        required: true;
                    };
                }>, {
                    colorClass: ComputedRef<"vs-blue" | "vs-green" | "vs-yellow" | "vs-red" | "vs-none">;
                    icon: ComputedRef<"search" | "link" | "close" | "copy" | "drag" | "error" | "message" | "menu" | "success" | "info" | "warning" | "attachFile" | "check" | "expandLess" | "expandMore" | "goFirst" | "goLast" | "goNext" | "goPrev" | "keyboardArrowUp" | "keyboardArrowDown" | "noData" | "radioChecked" | "radioUnchecked" | "rotateRight" | "themeDark" | "themeLight" | "unfoldMore" | null>;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                    dense: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    message: {
                        type: PropType<import('../../declaration').StateMessage>;
                        required: true;
                    };
                }>> & Readonly<{}>, {
                    dense: boolean;
                }, {}, {
                    VsIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                        icon: {
                            type: PropType<keyof typeof import('../..').iconSvgs>;
                            required: true;
                        };
                        size: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: number;
                        };
                    }>, {
                        iconSvgs: {
                            attachFile: string;
                            check: string;
                            close: string;
                            copy: string;
                            drag: string;
                            error: string;
                            expandLess: string;
                            expandMore: string;
                            goFirst: string;
                            goLast: string;
                            goNext: string;
                            goPrev: string;
                            info: string;
                            link: string;
                            keyboardArrowUp: string;
                            keyboardArrowDown: string;
                            menu: string;
                            message: string;
                            noData: string;
                            radioChecked: string;
                            radioUnchecked: string;
                            rotateRight: string;
                            search: string;
                            success: string;
                            themeDark: string;
                            themeLight: string;
                            unfoldMore: string;
                            warning: string;
                        };
                        computedSize: ComputedRef<{
                            width?: undefined;
                            height?: undefined;
                        } | {
                            width: string;
                            height: string;
                        }>;
                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                        icon: {
                            type: PropType<keyof typeof import('../..').iconSvgs>;
                            required: true;
                        };
                        size: {
                            type: (NumberConstructor | StringConstructor)[];
                            default: number;
                        };
                    }>> & Readonly<{}>, {
                        size: string | number;
                    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            VsIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                icon: {
                    type: PropType<keyof typeof import('../..').iconSvgs>;
                    required: true;
                };
                size: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: number;
                };
            }>, {
                iconSvgs: {
                    attachFile: string;
                    check: string;
                    close: string;
                    copy: string;
                    drag: string;
                    error: string;
                    expandLess: string;
                    expandMore: string;
                    goFirst: string;
                    goLast: string;
                    goNext: string;
                    goPrev: string;
                    info: string;
                    link: string;
                    keyboardArrowUp: string;
                    keyboardArrowDown: string;
                    menu: string;
                    message: string;
                    noData: string;
                    radioChecked: string;
                    radioUnchecked: string;
                    rotateRight: string;
                    search: string;
                    success: string;
                    themeDark: string;
                    themeLight: string;
                    unfoldMore: string;
                    warning: string;
                };
                computedSize: ComputedRef<{
                    width?: undefined;
                    height?: undefined;
                } | {
                    width: string;
                    height: string;
                }>;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                icon: {
                    type: PropType<keyof typeof import('../..').iconSvgs>;
                    required: true;
                };
                size: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: number;
                };
            }>> & Readonly<{}>, {
                size: string | number;
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    VsTableBody: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        checkboxStyleSet: {
            type: PropType<import('..').VsCheckboxNodeStyleSet>;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        expandedIds: {
            type: PropType<string[]>;
            default: () => never[];
        };
        filter: {
            type: PropType<TableFilter>;
            default: null;
        };
        hasExpand: {
            type: BooleanConstructor;
            default: boolean;
        };
        headers: {
            type: PropType<TableHeader[]>;
            required: true;
        };
        items: {
            type: PropType<any[]>;
            default: () => any[];
            required: true;
        };
        innerPage: {
            type: NumberConstructor;
            default: number;
        };
        innerItemsPerPage: {
            type: NumberConstructor;
            default: number;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        pagination: {
            type: BooleanConstructor;
            default: boolean;
        };
        rows: {
            type: PropType<TableRow>;
            default: () => {};
        };
        searchText: {
            type: StringConstructor;
            default: string;
        };
        searchableKeys: {
            type: PropType<string[]>;
            default: () => string[];
        };
        selectable: {
            type: BooleanConstructor;
            default: boolean;
        };
        selectedItems: {
            type: PropType<any[]>;
            default: () => any[];
        };
        sortTypes: {
            type: PropType<{
                [key: string]: SortType;
            }>;
            default: () => {};
        };
        trStyle: {
            type: PropType<{
                [key: string]: any;
            }>;
            default: () => {};
        };
        totalLength: {
            type: NumberConstructor;
            default: number;
        };
        isSelectedAll: {
            type: BooleanConstructor;
            default: boolean;
        };
        totalItemsLength: {
            type: NumberConstructor;
            default: number;
        };
    }>, {
        computedTableItems: import('vue').WritableComputedRef<import('./types').TableItem[], import('./types').TableItem[]>;
        dummyTableItems: {
            id: string;
            data: any;
        }[];
        utils: {
            clipboard: {
                copy(text: string): void;
            };
            device: {
                isTouchDevice: () => boolean;
            };
            dom: {
                isBrowser(): boolean;
                getClientRect(element: HTMLElement): DOMRect;
            };
            log: {
                error(target: string, message: string): void;
                warning(target: string, message: string): void;
                propError(componentName: string, property: string, message: string): void;
                propWarning(componentName: string, property: string, message: string): void;
            };
            function: {
                debounce(func: (...args: any) => any, delay?: number): (...args: any) => any;
                throttle(func: (...args: any) => any, interval?: number): (...args: any) => any;
            };
            object: {
                get: <TDefault = unknown>(value: any, path: string, defaultValue?: TDefault | undefined) => TDefault;
                isEqual: <TType>(x: TType, y: TType) => boolean;
                isArray: (arg: any) => arg is any[];
                unique: <T, K extends string | number | symbol>(array: readonly T[], toKey?: ((item: T) => K) | undefined) => T[];
                isUniq(array: any[]): boolean;
                isPlainObject(value: any): value is Record<string, any>;
                omit: <T, TKeys extends keyof T>(obj: T, keys: TKeys[]) => Omit<T, TKeys>;
                pick: <T extends object, TKeys extends keyof T>(obj: T, keys: TKeys[]) => Pick<T, TKeys>;
                pickWithPath(object: Record<string, any>, keys: string[]): Pick<string, any>;
                shake: <RemovedKeys extends string, T>(obj: T, filter?: (value: any) => boolean) => Omit<T, RemovedKeys>;
            };
            props: {
                checkPropExist<T = any>(componentName: string, property: string, options: any, value: T): boolean;
                checkValidNumber(componentName: string, property: string, value: number | string): boolean;
            };
            string: {
                createID(size?: number): string;
                pascalToKebab(str: string): string;
                convertToString(value: any): string;
                convertToStringSize(size: string | number): string;
                toFileSizeFormat(number: number | undefined | null): string;
            };
        };
        isSelected: (id: string) => boolean;
        toggleSelect: (check: boolean, id: string) => void;
        isExpanded: (id: string) => boolean;
        toggleExpand: (id: string) => void;
        emitClickRow: (rowItem: any, rowIndex: number) => void;
        emitDrag: (evt: SortableEvent) => void;
        expand: (index: number) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("drag" | "change:selectedItems" | "update:isSelectedAll" | "toggleExpand" | "clickRow" | "change:totalItems" | "change:pagedItems" | "update:totalItemsLength")[], "drag" | "change:selectedItems" | "update:isSelectedAll" | "toggleExpand" | "clickRow" | "change:totalItems" | "change:pagedItems" | "update:totalItemsLength", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        checkboxStyleSet: {
            type: PropType<import('..').VsCheckboxNodeStyleSet>;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        expandedIds: {
            type: PropType<string[]>;
            default: () => never[];
        };
        filter: {
            type: PropType<TableFilter>;
            default: null;
        };
        hasExpand: {
            type: BooleanConstructor;
            default: boolean;
        };
        headers: {
            type: PropType<TableHeader[]>;
            required: true;
        };
        items: {
            type: PropType<any[]>;
            default: () => any[];
            required: true;
        };
        innerPage: {
            type: NumberConstructor;
            default: number;
        };
        innerItemsPerPage: {
            type: NumberConstructor;
            default: number;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        pagination: {
            type: BooleanConstructor;
            default: boolean;
        };
        rows: {
            type: PropType<TableRow>;
            default: () => {};
        };
        searchText: {
            type: StringConstructor;
            default: string;
        };
        searchableKeys: {
            type: PropType<string[]>;
            default: () => string[];
        };
        selectable: {
            type: BooleanConstructor;
            default: boolean;
        };
        selectedItems: {
            type: PropType<any[]>;
            default: () => any[];
        };
        sortTypes: {
            type: PropType<{
                [key: string]: SortType;
            }>;
            default: () => {};
        };
        trStyle: {
            type: PropType<{
                [key: string]: any;
            }>;
            default: () => {};
        };
        totalLength: {
            type: NumberConstructor;
            default: number;
        };
        isSelectedAll: {
            type: BooleanConstructor;
            default: boolean;
        };
        totalItemsLength: {
            type: NumberConstructor;
            default: number;
        };
    }>> & Readonly<{
        onDrag?: ((...args: any[]) => any) | undefined;
        onToggleExpand?: ((...args: any[]) => any) | undefined;
        "onChange:selectedItems"?: ((...args: any[]) => any) | undefined;
        "onUpdate:isSelectedAll"?: ((...args: any[]) => any) | undefined;
        onClickRow?: ((...args: any[]) => any) | undefined;
        "onChange:totalItems"?: ((...args: any[]) => any) | undefined;
        "onChange:pagedItems"?: ((...args: any[]) => any) | undefined;
        "onUpdate:totalItemsLength"?: ((...args: any[]) => any) | undefined;
    }>, {
        filter: TableFilter;
        loading: boolean;
        selectable: boolean;
        draggable: boolean;
        trStyle: {
            [key: string]: any;
        };
        sortTypes: {
            [key: string]: SortType;
        };
        rows: TableRow<any>;
        expandedIds: string[];
        hasExpand: boolean;
        items: any[];
        innerPage: number;
        innerItemsPerPage: number;
        pagination: boolean;
        searchText: string;
        searchableKeys: string[];
        selectedItems: any[];
        totalLength: number;
        isSelectedAll: boolean;
        totalItemsLength: number;
    }, {}, {
        draggable: import('vue').DefineComponent<{
            list: {
                type: ArrayConstructor;
                required: boolean;
                default: any;
            };
            modelValue: {
                type: ArrayConstructor;
                required: boolean;
                default: any;
            };
            itemKey: {
                type: (FunctionConstructor | StringConstructor)[];
                required: boolean;
            };
            clone: {
                type: FunctionConstructor;
                default: (original: any) => any;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            move: {
                type: FunctionConstructor;
                default: any;
            };
            componentData: {
                type: ObjectConstructor;
                required: boolean;
                default: any;
            };
        }, unknown, {
            error: boolean;
        }, {
            realList(): any;
            getKey(): any;
        }, {
            getUnderlyingVm(domElement: any): any;
            getUnderlyingPotencialDraggableComponent(htmElement: any): any;
            emitChanges(evt: any): void;
            alterList(onList: any): void;
            spliceList(): void;
            updatePosition(oldIndex: any, newIndex: any): void;
            getRelatedContextFromMoveEvent({ to, related }: {
                to: any;
                related: any;
            }): any;
            getVmIndexFromDomIndex(domIndex: any): any;
            onDragStart(evt: any): void;
            onDragAdd(evt: any): void;
            onDragRemove(evt: any): void;
            onDragUpdate(evt: any): void;
            computeFutureIndex(relatedContext: any, evt: any): any;
            onDragMove(evt: any, originalEvent: any): any;
            onDragEnd(): void;
        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, any[], any, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<{
            move: Function;
            tag: string;
            clone: Function;
            list: unknown[];
            modelValue: unknown[];
            componentData: Record<string, any>;
        } & {
            itemKey?: string | Function;
        }>, {
            move: Function;
            tag: string;
            clone: Function;
            list: unknown[];
            modelValue: unknown[];
            componentData: Record<string, any>;
        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        VsTableBodyRow: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            draggable: {
                type: BooleanConstructor;
                default: boolean;
            };
            expanded: {
                type: BooleanConstructor;
                default: boolean;
            };
            expandable: {
                type: BooleanConstructor;
                default: boolean;
            };
            headers: {
                type: PropType<TableHeader[]>;
                required: true;
            };
            item: {
                type: PropType<import('./types').TableItem>;
                required: true;
            };
            rowIndex: {
                type: NumberConstructor;
                required: true;
            };
            rows: {
                type: PropType<TableRow>;
                default: () => {};
            };
            selectable: {
                type: BooleanConstructor;
                default: boolean;
            };
            selected: {
                type: BooleanConstructor;
                default: boolean;
            };
            trStyle: {
                type: PropType<{
                    [key: string]: any;
                }>;
                default: () => {};
            };
        }>, {
            isDummyRow: ComputedRef<boolean>;
            isSelectableRow: ComputedRef<boolean>;
            isExpandableRow: ComputedRef<boolean>;
            rowState: ComputedRef<import('../../declaration').UIState | undefined>;
            getRowData: (row: {
                [key: string]: any;
            }) => {
                key: string;
                value: any;
            }[];
            getHeader: (key: string) => TableHeader | undefined;
            getTableData: (key: string, value: any, rowItem: any) => any;
            emitToggleExpand: (id: string) => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "toggleExpand"[], "toggleExpand", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            draggable: {
                type: BooleanConstructor;
                default: boolean;
            };
            expanded: {
                type: BooleanConstructor;
                default: boolean;
            };
            expandable: {
                type: BooleanConstructor;
                default: boolean;
            };
            headers: {
                type: PropType<TableHeader[]>;
                required: true;
            };
            item: {
                type: PropType<import('./types').TableItem>;
                required: true;
            };
            rowIndex: {
                type: NumberConstructor;
                required: true;
            };
            rows: {
                type: PropType<TableRow>;
                default: () => {};
            };
            selectable: {
                type: BooleanConstructor;
                default: boolean;
            };
            selected: {
                type: BooleanConstructor;
                default: boolean;
            };
            trStyle: {
                type: PropType<{
                    [key: string]: any;
                }>;
                default: () => {};
            };
        }>> & Readonly<{
            onToggleExpand?: ((...args: any[]) => any) | undefined;
        }>, {
            selected: boolean;
            loading: boolean;
            selectable: boolean;
            draggable: boolean;
            expandable: boolean;
            trStyle: {
                [key: string]: any;
            };
            expanded: boolean;
            rows: TableRow<any>;
        }, {}, {
            VsIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                icon: {
                    type: PropType<keyof typeof import('../..').iconSvgs>;
                    required: true;
                };
                size: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: number;
                };
            }>, {
                iconSvgs: {
                    attachFile: string;
                    check: string;
                    close: string;
                    copy: string;
                    drag: string;
                    error: string;
                    expandLess: string;
                    expandMore: string;
                    goFirst: string;
                    goLast: string;
                    goNext: string;
                    goPrev: string;
                    info: string;
                    link: string;
                    keyboardArrowUp: string;
                    keyboardArrowDown: string;
                    menu: string;
                    message: string;
                    noData: string;
                    radioChecked: string;
                    radioUnchecked: string;
                    rotateRight: string;
                    search: string;
                    success: string;
                    themeDark: string;
                    themeLight: string;
                    unfoldMore: string;
                    warning: string;
                };
                computedSize: ComputedRef<{
                    width?: undefined;
                    height?: undefined;
                } | {
                    width: string;
                    height: string;
                }>;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                icon: {
                    type: PropType<keyof typeof import('../..').iconSvgs>;
                    required: true;
                };
                size: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: number;
                };
            }>> & Readonly<{}>, {
                size: string | number;
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            VsSkeleton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                styleSet: {
                    type: PropType<string | import('..').VsSkeletonStyleSet>;
                };
            }>, {
                colorSchemeClass: ComputedRef<string>;
                computedStyleSet: ComputedRef<{
                    [key: string]: any;
                }>;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                styleSet: {
                    type: PropType<string | import('..').VsSkeletonStyleSet>;
                };
            }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        VsIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            icon: {
                type: PropType<keyof typeof import('../..').iconSvgs>;
                required: true;
            };
            size: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
            };
        }>, {
            iconSvgs: {
                attachFile: string;
                check: string;
                close: string;
                copy: string;
                drag: string;
                error: string;
                expandLess: string;
                expandMore: string;
                goFirst: string;
                goLast: string;
                goNext: string;
                goPrev: string;
                info: string;
                link: string;
                keyboardArrowUp: string;
                keyboardArrowDown: string;
                menu: string;
                message: string;
                noData: string;
                radioChecked: string;
                radioUnchecked: string;
                rotateRight: string;
                search: string;
                success: string;
                themeDark: string;
                themeLight: string;
                unfoldMore: string;
                warning: string;
            };
            computedSize: ComputedRef<{
                width?: undefined;
                height?: undefined;
            } | {
                width: string;
                height: string;
            }>;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            icon: {
                type: PropType<keyof typeof import('../..').iconSvgs>;
                required: true;
            };
            size: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
            };
        }>> & Readonly<{}>, {
            size: string | number;
        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        VsCheckboxNode: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            styleSet: {
                type: PropType<string | import('..').VsCheckboxNodeStyleSet>;
            };
            ariaLabel: {
                type: StringConstructor;
                default: string;
            };
            checked: {
                type: BooleanConstructor;
                default: boolean;
            };
            dense: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            indeterminate: {
                type: BooleanConstructor;
                default: boolean;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
            name: {
                type: StringConstructor;
                default: string;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            required: {
                type: BooleanConstructor;
                default: boolean;
            };
            state: {
                type: PropType<import('../../declaration').UIState>;
                default: string;
            };
            value: {
                type: null;
                default: string;
            };
        }>, {
            checkboxRef: Ref<HTMLInputElement | null, HTMLInputElement | null>;
            colorSchemeClass: ComputedRef<string>;
            classObj: ComputedRef<{
                'vs-checked': boolean;
                'vs-dense': boolean;
                'vs-disabled': boolean;
                'vs-readonly': boolean;
                'vs-indeterminate': boolean;
            }>;
            onFocus: (event: FocusEvent) => void;
            onBlur: (event: FocusEvent) => void;
            focus: () => void;
            blur: () => void;
            convertToString: (value: any) => string;
            stateClasses: ComputedRef<{
                [x: string]: boolean;
                'vs-state-box': boolean;
            }>;
            computedStyleSet: ComputedRef<{
                [key: string]: any;
            }>;
            computedId: ComputedRef<string>;
            toggle: (event: Event) => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("blur" | "change" | "focus" | "toggle")[], "blur" | "change" | "focus" | "toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            styleSet: {
                type: PropType<string | import('..').VsCheckboxNodeStyleSet>;
            };
            ariaLabel: {
                type: StringConstructor;
                default: string;
            };
            checked: {
                type: BooleanConstructor;
                default: boolean;
            };
            dense: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            indeterminate: {
                type: BooleanConstructor;
                default: boolean;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
            name: {
                type: StringConstructor;
                default: string;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            required: {
                type: BooleanConstructor;
                default: boolean;
            };
            state: {
                type: PropType<import('../../declaration').UIState>;
                default: string;
            };
            value: {
                type: null;
                default: string;
            };
        }>> & Readonly<{
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            onFocus?: ((...args: any[]) => any) | undefined;
            onToggle?: ((...args: any[]) => any) | undefined;
        }>, {
            required: boolean;
            name: string;
            label: string;
            value: any;
            disabled: boolean;
            readonly: boolean;
            id: string;
            state: import('../../declaration').UIState;
            ariaLabel: string;
            dense: boolean;
            checked: boolean;
            indeterminate: boolean;
        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    VsCheckboxNode: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        styleSet: {
            type: PropType<string | import('..').VsCheckboxNodeStyleSet>;
        };
        ariaLabel: {
            type: StringConstructor;
            default: string;
        };
        checked: {
            type: BooleanConstructor;
            default: boolean;
        };
        dense: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        id: {
            type: StringConstructor;
            default: string;
        };
        indeterminate: {
            type: BooleanConstructor;
            default: boolean;
        };
        label: {
            type: StringConstructor;
            default: string;
        };
        name: {
            type: StringConstructor;
            default: string;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        required: {
            type: BooleanConstructor;
            default: boolean;
        };
        state: {
            type: PropType<import('../../declaration').UIState>;
            default: string;
        };
        value: {
            type: null;
            default: string;
        };
    }>, {
        checkboxRef: Ref<HTMLInputElement | null, HTMLInputElement | null>;
        colorSchemeClass: ComputedRef<string>;
        classObj: ComputedRef<{
            'vs-checked': boolean;
            'vs-dense': boolean;
            'vs-disabled': boolean;
            'vs-readonly': boolean;
            'vs-indeterminate': boolean;
        }>;
        onFocus: (event: FocusEvent) => void;
        onBlur: (event: FocusEvent) => void;
        focus: () => void;
        blur: () => void;
        convertToString: (value: any) => string;
        stateClasses: ComputedRef<{
            [x: string]: boolean;
            'vs-state-box': boolean;
        }>;
        computedStyleSet: ComputedRef<{
            [key: string]: any;
        }>;
        computedId: ComputedRef<string>;
        toggle: (event: Event) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("blur" | "change" | "focus" | "toggle")[], "blur" | "change" | "focus" | "toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        styleSet: {
            type: PropType<string | import('..').VsCheckboxNodeStyleSet>;
        };
        ariaLabel: {
            type: StringConstructor;
            default: string;
        };
        checked: {
            type: BooleanConstructor;
            default: boolean;
        };
        dense: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        id: {
            type: StringConstructor;
            default: string;
        };
        indeterminate: {
            type: BooleanConstructor;
            default: boolean;
        };
        label: {
            type: StringConstructor;
            default: string;
        };
        name: {
            type: StringConstructor;
            default: string;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        required: {
            type: BooleanConstructor;
            default: boolean;
        };
        state: {
            type: PropType<import('../../declaration').UIState>;
            default: string;
        };
        value: {
            type: null;
            default: string;
        };
    }>> & Readonly<{
        onBlur?: ((...args: any[]) => any) | undefined;
        onChange?: ((...args: any[]) => any) | undefined;
        onFocus?: ((...args: any[]) => any) | undefined;
        onToggle?: ((...args: any[]) => any) | undefined;
    }>, {
        required: boolean;
        name: string;
        label: string;
        value: any;
        disabled: boolean;
        readonly: boolean;
        id: string;
        state: import('../../declaration').UIState;
        ariaLabel: string;
        dense: boolean;
        checked: boolean;
        indeterminate: boolean;
    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    VsPagination: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        styleSet: {
            type: PropType<string | import('..').VsPaginationStyleSet>;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        edgeButtons: {
            type: BooleanConstructor;
            default: boolean;
        };
        length: {
            type: NumberConstructor;
            required: true;
            default: number;
            validator: (value: number) => boolean;
        };
        showingLength: {
            type: NumberConstructor;
            default: number;
            validator: (value: number) => boolean;
        };
        modelValue: {
            type: NumberConstructor;
            default: number;
        };
    }>, {
        colorSchemeClass: ComputedRef<string>;
        computedStyleSet: ComputedRef<{
            [key: string]: any;
        }>;
        selected: Ref<number, number>;
        pages: ComputedRef<number[]>;
        goFirst: () => void;
        goLast: () => void;
        goPrev: () => void;
        goNext: () => void;
        setPage: (page: number) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        styleSet: {
            type: PropType<string | import('..').VsPaginationStyleSet>;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        edgeButtons: {
            type: BooleanConstructor;
            default: boolean;
        };
        length: {
            type: NumberConstructor;
            required: true;
            default: number;
            validator: (value: number) => boolean;
        };
        showingLength: {
            type: NumberConstructor;
            default: number;
            validator: (value: number) => boolean;
        };
        modelValue: {
            type: NumberConstructor;
            default: number;
        };
    }>> & Readonly<{
        onChange?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {
        length: number;
        disabled: boolean;
        modelValue: number;
        edgeButtons: boolean;
        showingLength: number;
    }, {}, {
        VsIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            icon: {
                type: PropType<keyof typeof import('../..').iconSvgs>;
                required: true;
            };
            size: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
            };
        }>, {
            iconSvgs: {
                attachFile: string;
                check: string;
                close: string;
                copy: string;
                drag: string;
                error: string;
                expandLess: string;
                expandMore: string;
                goFirst: string;
                goLast: string;
                goNext: string;
                goPrev: string;
                info: string;
                link: string;
                keyboardArrowUp: string;
                keyboardArrowDown: string;
                menu: string;
                message: string;
                noData: string;
                radioChecked: string;
                radioUnchecked: string;
                rotateRight: string;
                search: string;
                success: string;
                themeDark: string;
                themeLight: string;
                unfoldMore: string;
                warning: string;
            };
            computedSize: ComputedRef<{
                width?: undefined;
                height?: undefined;
            } | {
                width: string;
                height: string;
            }>;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            icon: {
                type: PropType<keyof typeof import('../..').iconSvgs>;
                required: true;
            };
            size: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
            };
        }>> & Readonly<{}>, {
            size: string | number;
        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    VsSelect: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        styleSet: {
            type: PropType<string | import('..').VsSelectStyleSet>;
        };
        autocomplete: {
            type: BooleanConstructor;
            default: boolean;
        };
        closableChips: {
            type: BooleanConstructor;
            default: boolean;
            validator: (value: unknown, props: {
                [x: string]: unknown;
            }) => boolean;
        };
        collapseChips: {
            type: BooleanConstructor;
            default: boolean;
            validator: (value: unknown, props: {
                [x: string]: unknown;
            }) => boolean;
        };
        lazyLoadNum: {
            type: NumberConstructor;
            default: number;
            validator: (value: number) => boolean;
        };
        max: {
            type: (NumberConstructor | StringConstructor)[];
            default: number;
            validator: (value: number | string) => boolean;
        };
        min: {
            type: (NumberConstructor | StringConstructor)[];
            default: number;
            validator: (value: number | string) => boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        selectAll: {
            type: BooleanConstructor;
            default: boolean;
            validator: (value: unknown, props: {
                [x: string]: unknown;
            }) => boolean;
        };
        modelValue: {
            type: null;
            default: null;
        };
        width: {
            type: PropType<string | number | import('../../declaration').Breakpoints>;
            default: null;
        };
        grid: {
            type: PropType<string | number | import('../../declaration').Breakpoints>;
            default: null;
        };
        options: {
            type: PropType<any[]>;
            required: boolean;
            default: () => never[];
        };
        optionLabel: {
            type: StringConstructor;
            default: string;
        };
        optionValue: {
            type: StringConstructor;
            default: string;
        };
        required: {
            type: BooleanConstructor;
            default: boolean;
        };
        name: {
            type: StringConstructor;
            default: string;
        };
        label: {
            type: StringConstructor;
            default: string;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        id: {
            type: StringConstructor;
            default: string;
        };
        messages: {
            type: PropType<import('../../declaration').Message<any>[]>;
            default: () => import('../../declaration').Message<any>[];
        };
        rules: {
            type: PropType<import('../../declaration').Rule<any>[]>;
            default: () => import('../../declaration').Rule<any>[];
        };
        noDefaultRules: {
            type: BooleanConstructor;
            default: boolean;
        };
        state: {
            type: PropType<import('../../declaration').UIState>;
            default: import('../../declaration').UIState;
        };
        ariaLabel: {
            type: StringConstructor;
            default: null;
        };
        dense: {
            type: BooleanConstructor;
            default: boolean;
        };
        noClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        noMessage: {
            type: BooleanConstructor;
            default: boolean;
        };
        placeholder: {
            type: StringConstructor;
            default: string;
        };
        visible: {
            type: BooleanConstructor;
            default: boolean;
        };
        changed: {
            type: BooleanConstructor;
            default: boolean;
        };
        valid: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, {
        computedId: ComputedRef<string>;
        classObj: ComputedRef<{
            'vs-dense': boolean;
            'vs-disabled': boolean;
            'vs-readonly': boolean;
        }>;
        colorSchemeClass: ComputedRef<string>;
        computedStyleSet: ComputedRef<{
            [key: string]: any;
        }>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        animationClass: ComputedRef<"fade-enter-bottom" | "fade-enter-top" | "fade-leave-bottom" | "fade-leave-top">;
        inputValue: Ref<any, any>;
        computedMessages: ComputedRef<import('../../declaration').StateMessage<import('../../declaration').UIState>[]>;
        shake: Ref<boolean, boolean>;
        triggerRef: Ref<HTMLElement | null, HTMLElement | null>;
        optionsRef: Ref<HTMLElement | null, HTMLElement | null>;
        isVisible: Ref<boolean, boolean>;
        inputLabel: ComputedRef<string>;
        isOpen: Ref<boolean, boolean>;
        isClosing: Ref<boolean, boolean>;
        toggleOptions: () => void;
        closeOptions: () => void;
        listboxRef: Ref<HTMLElement | null, HTMLElement | null>;
        filteredOptions: Ref<{
            id: string;
            value: any;
        }[], {
            id: string;
            value: any;
        }[]>;
        loadedOptions: Ref<{
            id: string;
            value: any;
        }[], {
            id: string;
            value: any;
        }[]>;
        getOptionLabel: (option: any) => string;
        getOptionValue: (option: any) => any;
        removeSelected: (option: any) => void;
        selectOption: (option: any) => void;
        selectAllOptions: () => void;
        isSelectedOption: (option: any) => boolean;
        isAllSelected: ComputedRef<boolean>;
        selectedOptions: ComputedRef<any>;
        onClear: () => void;
        clear: () => void;
        validate: () => boolean;
        updateAutocompleteText: (text: string) => void;
        focusedIndex: Ref<number, number>;
        hoveredIndex: Ref<number, number>;
        chasingMouse: Ref<boolean, boolean>;
        onMouseMove: (...args: any) => any;
        isChasedOption: (optionIndex: number) => boolean;
        focusedOptionId: ComputedRef<string>;
        onFocus: (e: FocusEvent) => void;
        onBlur: (e: FocusEvent) => void;
        inputRef: Ref<HTMLInputElement | null, HTMLInputElement | null>;
        focus: () => void;
        blur: () => void;
        stateClasses: ComputedRef<{
            [x: string]: boolean;
            'vs-state-box': boolean;
        }>;
        onInput: (e: Event) => void;
        onComboboxKeydown: (event: KeyboardEvent) => void;
        onClickTrigger: () => void;
        open: () => void;
        close: () => void;
        VS_OVERLAY_ID: string;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("blur" | "change" | "focus" | "update:modelValue" | "update:valid" | "update:changed")[], "blur" | "change" | "focus" | "update:modelValue" | "update:valid" | "update:changed", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        styleSet: {
            type: PropType<string | import('..').VsSelectStyleSet>;
        };
        autocomplete: {
            type: BooleanConstructor;
            default: boolean;
        };
        closableChips: {
            type: BooleanConstructor;
            default: boolean;
            validator: (value: unknown, props: {
                [x: string]: unknown;
            }) => boolean;
        };
        collapseChips: {
            type: BooleanConstructor;
            default: boolean;
            validator: (value: unknown, props: {
                [x: string]: unknown;
            }) => boolean;
        };
        lazyLoadNum: {
            type: NumberConstructor;
            default: number;
            validator: (value: number) => boolean;
        };
        max: {
            type: (NumberConstructor | StringConstructor)[];
            default: number;
            validator: (value: number | string) => boolean;
        };
        min: {
            type: (NumberConstructor | StringConstructor)[];
            default: number;
            validator: (value: number | string) => boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        selectAll: {
            type: BooleanConstructor;
            default: boolean;
            validator: (value: unknown, props: {
                [x: string]: unknown;
            }) => boolean;
        };
        modelValue: {
            type: null;
            default: null;
        };
        width: {
            type: PropType<string | number | import('../../declaration').Breakpoints>;
            default: null;
        };
        grid: {
            type: PropType<string | number | import('../../declaration').Breakpoints>;
            default: null;
        };
        options: {
            type: PropType<any[]>;
            required: boolean;
            default: () => never[];
        };
        optionLabel: {
            type: StringConstructor;
            default: string;
        };
        optionValue: {
            type: StringConstructor;
            default: string;
        };
        required: {
            type: BooleanConstructor;
            default: boolean;
        };
        name: {
            type: StringConstructor;
            default: string;
        };
        label: {
            type: StringConstructor;
            default: string;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        id: {
            type: StringConstructor;
            default: string;
        };
        messages: {
            type: PropType<import('../../declaration').Message<any>[]>;
            default: () => import('../../declaration').Message<any>[];
        };
        rules: {
            type: PropType<import('../../declaration').Rule<any>[]>;
            default: () => import('../../declaration').Rule<any>[];
        };
        noDefaultRules: {
            type: BooleanConstructor;
            default: boolean;
        };
        state: {
            type: PropType<import('../../declaration').UIState>;
            default: import('../../declaration').UIState;
        };
        ariaLabel: {
            type: StringConstructor;
            default: null;
        };
        dense: {
            type: BooleanConstructor;
            default: boolean;
        };
        noClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        noMessage: {
            type: BooleanConstructor;
            default: boolean;
        };
        placeholder: {
            type: StringConstructor;
            default: string;
        };
        visible: {
            type: BooleanConstructor;
            default: boolean;
        };
        changed: {
            type: BooleanConstructor;
            default: boolean;
        };
        valid: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onBlur?: ((...args: any[]) => any) | undefined;
        onChange?: ((...args: any[]) => any) | undefined;
        onFocus?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        "onUpdate:valid"?: ((...args: any[]) => any) | undefined;
        "onUpdate:changed"?: ((...args: any[]) => any) | undefined;
    }>, {
        width: string | number | import('../../declaration').Breakpoints;
        required: boolean;
        name: string;
        label: string;
        disabled: boolean;
        readonly: boolean;
        modelValue: any;
        id: string;
        messages: import('../../declaration').Message<any>[];
        rules: import('../../declaration').Rule<any>[];
        noDefaultRules: boolean;
        state: import('../../declaration').UIState;
        ariaLabel: string;
        dense: boolean;
        noClear: boolean;
        noMessage: boolean;
        placeholder: string;
        visible: boolean;
        changed: boolean;
        valid: boolean;
        grid: string | number | import('../../declaration').Breakpoints;
        multiple: boolean;
        max: string | number;
        min: string | number;
        options: any[];
        optionLabel: string;
        optionValue: string;
        autocomplete: boolean;
        closableChips: boolean;
        collapseChips: boolean;
        lazyLoadNum: number;
        selectAll: boolean;
    }, {}, {
        VsInputWrapper: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            dense: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            groupLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
            messages: {
                type: PropType<import('../../declaration').StateMessage[]>;
                default: () => never[];
            };
            noMessage: {
                type: BooleanConstructor;
                default: boolean;
            };
            required: {
                type: BooleanConstructor;
                default: boolean;
            };
            shake: {
                type: BooleanConstructor;
                default: boolean;
            };
            width: {
                type: PropType<string | number | import('../../declaration').Breakpoints>;
                default: null;
            };
            grid: {
                type: PropType<string | number | import('../../declaration').Breakpoints>;
                default: null;
            };
        }>, {
            colorSchemeClass: ComputedRef<string>;
            needToShake: Ref<boolean, boolean>;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            dense: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            groupLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
            messages: {
                type: PropType<import('../../declaration').StateMessage[]>;
                default: () => never[];
            };
            noMessage: {
                type: BooleanConstructor;
                default: boolean;
            };
            required: {
                type: BooleanConstructor;
                default: boolean;
            };
            shake: {
                type: BooleanConstructor;
                default: boolean;
            };
            width: {
                type: PropType<string | number | import('../../declaration').Breakpoints>;
                default: null;
            };
            grid: {
                type: PropType<string | number | import('../../declaration').Breakpoints>;
                default: null;
            };
        }>> & Readonly<{}>, {
            width: string | number | import('../../declaration').Breakpoints;
            required: boolean;
            label: string;
            disabled: boolean;
            id: string;
            messages: import('../../declaration').StateMessage<import('../../declaration').UIState>[];
            dense: boolean;
            noMessage: boolean;
            grid: string | number | import('../../declaration').Breakpoints;
            groupLabel: boolean;
            shake: boolean;
        }, {}, {
            VsResponsive: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | import('../../declaration').Breakpoints>;
                    default: null;
                };
                grid: {
                    type: PropType<string | number | import('../../declaration').Breakpoints>;
                    default: null;
                };
            }>, {
                responsiveClasses: ComputedRef<string[]>;
                responsiveStyles: ComputedRef<Record<string, string>>;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | import('../../declaration').Breakpoints>;
                    default: null;
                };
                grid: {
                    type: PropType<string | number | import('../../declaration').Breakpoints>;
                    default: null;
                };
            }>> & Readonly<{}>, {
                width: string | number | import('../../declaration').Breakpoints;
                tag: string;
                grid: string | number | import('../../declaration').Breakpoints;
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            VsMessage: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                dense: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                message: {
                    type: PropType<import('../../declaration').StateMessage>;
                    required: true;
                };
            }>, {
                colorClass: ComputedRef<"vs-blue" | "vs-green" | "vs-yellow" | "vs-red" | "vs-none">;
                icon: ComputedRef<"search" | "link" | "close" | "copy" | "drag" | "error" | "message" | "menu" | "success" | "info" | "warning" | "attachFile" | "check" | "expandLess" | "expandMore" | "goFirst" | "goLast" | "goNext" | "goPrev" | "keyboardArrowUp" | "keyboardArrowDown" | "noData" | "radioChecked" | "radioUnchecked" | "rotateRight" | "themeDark" | "themeLight" | "unfoldMore" | null>;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                dense: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                message: {
                    type: PropType<import('../../declaration').StateMessage>;
                    required: true;
                };
            }>> & Readonly<{}>, {
                dense: boolean;
            }, {}, {
                VsIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                    icon: {
                        type: PropType<keyof typeof import('../..').iconSvgs>;
                        required: true;
                    };
                    size: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: number;
                    };
                }>, {
                    iconSvgs: {
                        attachFile: string;
                        check: string;
                        close: string;
                        copy: string;
                        drag: string;
                        error: string;
                        expandLess: string;
                        expandMore: string;
                        goFirst: string;
                        goLast: string;
                        goNext: string;
                        goPrev: string;
                        info: string;
                        link: string;
                        keyboardArrowUp: string;
                        keyboardArrowDown: string;
                        menu: string;
                        message: string;
                        noData: string;
                        radioChecked: string;
                        radioUnchecked: string;
                        rotateRight: string;
                        search: string;
                        success: string;
                        themeDark: string;
                        themeLight: string;
                        unfoldMore: string;
                        warning: string;
                    };
                    computedSize: ComputedRef<{
                        width?: undefined;
                        height?: undefined;
                    } | {
                        width: string;
                        height: string;
                    }>;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                    icon: {
                        type: PropType<keyof typeof import('../..').iconSvgs>;
                        required: true;
                    };
                    size: {
                        type: (NumberConstructor | StringConstructor)[];
                        default: number;
                    };
                }>> & Readonly<{}>, {
                    size: string | number;
                }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        VsChip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            styleSet: {
                type: PropType<string | import('..').VsChipStyleSet>;
            };
            closable: {
                type: BooleanConstructor;
                default: boolean;
            };
            dense: {
                type: BooleanConstructor;
                default: boolean;
            };
            noRound: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            hasIcon: ComputedRef<boolean>;
            colorSchemeClass: ComputedRef<string>;
            computedStyleSet: ComputedRef<{
                [key: string]: any;
            }>;
            classObj: ComputedRef<{
                'vs-dense': boolean;
                'vs-no-round': boolean;
                'vs-primary': boolean;
            }>;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "close"[], "close", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            styleSet: {
                type: PropType<string | import('..').VsChipStyleSet>;
            };
            closable: {
                type: BooleanConstructor;
                default: boolean;
            };
            dense: {
                type: BooleanConstructor;
                default: boolean;
            };
            noRound: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onClose?: ((...args: any[]) => any) | undefined;
        }>, {
            dense: boolean;
            primary: boolean;
            closable: boolean;
            noRound: boolean;
        }, {}, {
            VsIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                icon: {
                    type: PropType<keyof typeof import('../..').iconSvgs>;
                    required: true;
                };
                size: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: number;
                };
            }>, {
                iconSvgs: {
                    attachFile: string;
                    check: string;
                    close: string;
                    copy: string;
                    drag: string;
                    error: string;
                    expandLess: string;
                    expandMore: string;
                    goFirst: string;
                    goLast: string;
                    goNext: string;
                    goPrev: string;
                    info: string;
                    link: string;
                    keyboardArrowUp: string;
                    keyboardArrowDown: string;
                    menu: string;
                    message: string;
                    noData: string;
                    radioChecked: string;
                    radioUnchecked: string;
                    rotateRight: string;
                    search: string;
                    success: string;
                    themeDark: string;
                    themeLight: string;
                    unfoldMore: string;
                    warning: string;
                };
                computedSize: ComputedRef<{
                    width?: undefined;
                    height?: undefined;
                } | {
                    width: string;
                    height: string;
                }>;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                icon: {
                    type: PropType<keyof typeof import('../..').iconSvgs>;
                    required: true;
                };
                size: {
                    type: (NumberConstructor | StringConstructor)[];
                    default: number;
                };
            }>> & Readonly<{}>, {
                size: string | number;
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        VsIcon: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            icon: {
                type: PropType<keyof typeof import('../..').iconSvgs>;
                required: true;
            };
            size: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
            };
        }>, {
            iconSvgs: {
                attachFile: string;
                check: string;
                close: string;
                copy: string;
                drag: string;
                error: string;
                expandLess: string;
                expandMore: string;
                goFirst: string;
                goLast: string;
                goNext: string;
                goPrev: string;
                info: string;
                link: string;
                keyboardArrowUp: string;
                keyboardArrowDown: string;
                menu: string;
                message: string;
                noData: string;
                radioChecked: string;
                radioUnchecked: string;
                rotateRight: string;
                search: string;
                success: string;
                themeDark: string;
                themeLight: string;
                unfoldMore: string;
                warning: string;
            };
            computedSize: ComputedRef<{
                width?: undefined;
                height?: undefined;
            } | {
                width: string;
                height: string;
            }>;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            icon: {
                type: PropType<keyof typeof import('../..').iconSvgs>;
                required: true;
            };
            size: {
                type: (NumberConstructor | StringConstructor)[];
                default: number;
            };
        }>> & Readonly<{}>, {
            size: string | number;
        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
export default _default;