import { AllowedComponentProps } from 'vue';
import { App } from 'vue';
import { Component } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComponentPublicInstance } from 'vue';
import { ComputedRef } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import { CSSProperties } from 'vue';
import { DeepReadonly } from 'vue';
import { DefineComponent } from 'vue';
import { Directive } from 'vue';
import { ExtractPropTypes } from 'vue';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { kebabCase } from 'change-case';
import { LucideIcon } from '@lucide/vue';
import { Options } from 'sortablejs';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import { ShallowRef } from 'vue';
import { SortableEvent } from 'sortablejs';
import { TemplateRef } from 'vue';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';
import { WritableComputedRef } from 'vue';

export declare const ALERT_OK = 'vlossom:alert-ok';

declare interface AlertModalOptions extends Omit<ModalOptions, 'beforeClose'> {
    styleSet?: VsAlertStyleSet;
    colorScheme?: ColorScheme;
    okText?: string;
}

declare interface AlertPlugin {
    open(content: string, options?: Omit<AlertModalOptions, 'componentProps'>): Promise<void>;
    open(content: Component, options?: AlertModalOptions): Promise<void>;
}

export declare type Alignment = (typeof ALIGNMENTS)[number];

export declare const ALIGNMENTS: readonly ['start', 'center', 'end'];

export declare const ANIMATION_DURATION = 300;

export declare interface AttachInfo {
    placement?: Placement;
    align?: Alignment;
    margin?: number;
    followWidth?: boolean;
}

export declare type AttrsOf<K extends keyof VsComponentRegistry> = InstanceType<VsComponentRegistry[K]>['$attrs'];

export declare interface BarLayout {
    position: CssPosition;
    height: string;
}

export declare interface Breakpoints {
    xs?: string | number;
    sm?: string | number;
    md?: string | number;
    lg?: string | number;
    xl?: string | number;
}

export declare const chromaticParameters: {
    theme: {
        modes: {
            light: {
                backgrounds: {
                    value: string;
                };
            };
            dark: {
                backgrounds: {
                    value: string;
                };
            };
        };
    };
    mobile: {
        modes: {
            mobile: {
                viewport: string;
            };
        };
    };
};

export declare const clipboardUtil: {
    copy(text: string): Promise<boolean>;
};

export declare const COLOR_SCHEMES: readonly [
    'brown',
    'red',
    'orange',
    'amber',
    'yellow',
    'lime',
    'green',
    'emerald',
    'teal',
    'cyan',
    'sky',
    'blue',
    'indigo',
    'violet',
    'purple',
    'fuchsia',
    'pink',
    'rose',
    'gray',
    'none',
];

export declare const COLORS: readonly [
    'brown',
    'red',
    'orange',
    'amber',
    'yellow',
    'lime',
    'green',
    'emerald',
    'teal',
    'cyan',
    'sky',
    'blue',
    'indigo',
    'violet',
    'purple',
    'fuchsia',
    'pink',
    'rose',
    'gray',
];

export declare type ColorScheme = (typeof COLOR_SCHEMES)[number];

export declare const colorScheme: {
    control: any;
    options: readonly [
        'brown',
        'red',
        'orange',
        'amber',
        'yellow',
        'lime',
        'green',
        'emerald',
        'teal',
        'cyan',
        'sky',
        'blue',
        'indigo',
        'violet',
        'purple',
        'fuchsia',
        'pink',
        'rose',
        'gray',
    ];
};

export declare const compareUtil: {
    compareValues: typeof compareValues;
};

declare function compareValues(aValue: unknown, bValue: unknown): number;

export declare const CONFIRM_CANCEL = 'vlossom:confirm-cancel';

export declare const CONFIRM_OK = 'vlossom:confirm-ok';

declare interface ConfirmModalOptions extends Omit<ModalOptions, 'beforeClose'> {
    styleSet?: VsConfirmStyleSet;
    colorScheme?: ColorScheme;
    okText?: string;
    cancelText?: string;
    swapButtons?: boolean;
}

declare interface ConfirmPlugin {
    open(content: string, options?: Omit<ConfirmModalOptions, 'componentProps'>): Promise<boolean>;
    open(content: Component, options?: ConfirmModalOptions): Promise<boolean>;
}

export declare class ContainerStore<
    T extends {
        container: string;
        id: string;
    },
> {
    private _map;
    map: Readonly<
        Ref<ReadonlyMap<string, readonly DeepReadonly<T>[]>, ReadonlyMap<string, readonly DeepReadonly<T>[]>>
    >;
    get size(): number;
    has(container: string): boolean;
    get(container: string): T[];
    set(container: string, value: T[]): void;
    push(container: string, value: T): void;
    remove(container: string, id: string): void;
    pop(container: string): void;
    delete(container: string): void;
    clear(): void;
    private _updateOrDelete;
}

export declare function createVlossom(options: VlossomOptions): any;

export declare type CssPosition = 'static' | 'relative' | 'absolute' | 'fixed' | 'sticky';

export declare const deviceUtil: {
    isTouchDevice: () => boolean;
};

export declare const domUtil: {
    isBrowser(): boolean;
    getClientRect(element: HTMLElement): DOMRect;
    isScrollableX(element: HTMLElement): boolean;
    isScrollableY(element: HTMLElement): boolean;
};

export declare interface DrawerLayout {
    isOpen: boolean;
    pushContainer: boolean;
    placement: DrawerPlacement;
    size: string;
}

export declare type DrawerLayouts = {
    [key in DrawerPlacement]: DrawerLayout;
};

export declare type DrawerPlacement = 'top' | 'bottom' | 'left' | 'right';

export declare type EmitsOf<K extends keyof VsComponentRegistry> = InstanceType<VsComponentRegistry[K]>['$emit'];

export declare type FileDropValueType = File[];

export declare interface FocusableRef {
    focus: () => void;
    blur: () => void;
}

export declare const FORM_STORE_KEY = 'vlossom:form-store';

export declare interface FormChildRef {
    validate: () => boolean;
    clear: () => void;
}

export declare class FormStore {
    private _disabled;
    private _readonly;
    private _changedObj;
    private _validObj;
    private _validateFlag;
    private _clearFlag;
    private _resetFlag;
    static getDefaultFormStore(): FormStore;
    disabled: ComputedRef<boolean>;
    setDisabled(value: boolean): void;
    readonly: ComputedRef<boolean>;
    setReadonly(value: boolean): void;
    changedObj: ComputedRef<Record<string, boolean>>;
    updateChanged(id: string, changed: boolean): void;
    validObj: ComputedRef<Record<string, boolean>>;
    updateValid(id: string, valid: boolean): void;
    removeFromForm(id: string): void;
    validateFlag: ComputedRef<boolean>;
    toggleValidateFlag(): void;
    clearFlag: ComputedRef<boolean>;
    toggleClearFlag(): void;
    resetFlag: ComputedRef<boolean>;
    toggleResetFlag(): void;
}

export declare const functionUtil: {
    throttle: <TArgs extends any[]>(
        {
            interval,
        }: {
            interval: number;
        },
        func: (...args: TArgs) => any,
    ) => {
        (...args: TArgs): void;
        isThrottled(): boolean;
    };
    debounce: <TArgs extends any[]>(
        {
            delay,
        }: {
            delay: number;
        },
        func: (...args: TArgs) => any,
    ) => {
        (...args: TArgs): void;
        cancel(): void;
        isPending(): boolean;
        flush(...args: TArgs): void;
    };
    toCallable: typeof toCallable;
};

export declare function getButtonProps(): {
    circle: {
        type: BooleanConstructor;
        default: boolean;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    ghost: {
        type: BooleanConstructor;
        default: boolean;
    };
    loading: {
        type: BooleanConstructor;
        default: boolean;
    };
    outline: {
        type: BooleanConstructor;
        default: boolean;
    };
    primary: {
        type: BooleanConstructor;
        default: boolean;
    };
    responsive: {
        type: BooleanConstructor;
        default: boolean;
    };
    size: {
        type: PropType<Size>;
        default: string;
    };
    type: {
        type: PropType<'button' | 'submit' | 'reset'>;
        default: string;
    };
};

export declare function getColorSchemeProps(): {
    colorScheme: {
        type: PropType<ColorScheme>;
    };
};

export declare function getColorSchemeTemplate(templateStr: string): string;

export declare function getFloatingProps(defaultValues?: { placement: Placement; align: Alignment; margin: number }): {
    target: {
        type: StringConstructor;
        required: boolean;
        default: string;
    };
    align: {
        type: PropType<Alignment>;
        default: 'start' | 'center' | 'end';
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    enterDelay: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    leaveDelay: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    margin: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    noAnimation: {
        type: BooleanConstructor;
        default: boolean;
    };
    placement: {
        type: PropType<Placement>;
        default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
    };
};

export declare function getGridProps(): {
    gridSize: {
        type: (StringConstructor | NumberConstructor)[];
    };
    columnGap: {
        type: (StringConstructor | NumberConstructor)[];
    };
    rowGap: {
        type: (StringConstructor | NumberConstructor)[];
    };
};

export declare function getGroupByProps(): {
    groupBy: {
        type: PropType<(option: any, index: number) => string | null> | null;
        default: null;
    };
    groupOrder: {
        type: PropType<string[]>;
        default: () => never[];
    };
};

export declare function getInputProps<T = unknown, K extends keyof InputPropsDefinition<T> = never>(
    ...excludes: K[]
): Omit<InputPropsDefinition<T>, K>;

export declare function getInputWrapperProps(): InputWrapperPropsDefinition;

export declare function getLayoutProps(): {
    layout: {
        type: BooleanConstructor;
        default: boolean;
    };
};

export declare function getMinMaxProps(
    componentName: string,
    options?: {
        minDefault?: number | string;
        maxDefault?: number | string;
    },
): {
    min: {
        type: PropType<number | string>;
        default: string | number;
        validator: (value: number | string) => boolean;
    };
    max: {
        type: PropType<number | string>;
        default: string | number;
        validator: (value: number | string) => boolean;
    };
};

export declare function getOptionsProps(): {
    options: {
        type: PropType<any[]>;
        default: () => never[];
    };
    optionLabel: {
        type: StringConstructor;
        default: string;
    };
    optionValue: {
        type: StringConstructor;
        default: string;
    };
};

export declare function getOverlayProps(): {
    callbacks: {
        type: PropType<OverlayCallbacks>;
        default: () => {};
    };
    dimClose: {
        type: BooleanConstructor;
        default: boolean;
    };
    dimmed: {
        type: BooleanConstructor;
        default: boolean;
    };
    escClose: {
        type: BooleanConstructor;
        default: boolean;
    };
    focusLock: {
        type: BooleanConstructor;
        default: boolean;
    };
    hideScroll: {
        type: BooleanConstructor;
        default: boolean;
    };
    id: {
        type: StringConstructor;
        default: string;
    };
};

export declare function getPositionProps(): {
    position: {
        type: PropType<CssPosition>;
    };
};

export declare function getResponsiveProps(): {
    width: {
        type: PropType<string | number | Breakpoints>;
    };
    grid: {
        type: PropType<string | number | Breakpoints>;
    };
};

declare function getRowId(row: VsTableBodyCell[]): string | undefined;

declare function getRowItem(row: VsTableBodyCell[]): VsTableItem;

export declare function getSearchProps(): {
    search: {
        type: PropType<SearchProps>;
        default: boolean;
        validator: (value: SearchProps) => boolean;
    };
};

export declare function getStyleSetProps<
    T extends {
        [key: string]: any;
    },
>(): {
    styleSet: {
        type: PropType<string | T>;
    };
};

export declare type GlobalColorSchemes = {
    [key in VsComponent]?: ColorScheme;
} & {
    default?: ColorScheme;
} & {
    [key: string]: ColorScheme;
};

export declare type GlobalStyleSets = {
    [key: string]: {
        [key in VsComponent]?: any;
    } & {
        [key: string]: any;
    };
};

export declare function inheritAppContext(parent: App, overlay: App): void;

export declare interface InputComponentParams<T = unknown> {
    inputValue: Ref<T>;
    modelValue: Ref<T>;
    id?: Ref<string>;
    disabled?: Ref<boolean>;
    readonly?: Ref<boolean>;
    messages?: Ref<Message<T>[]>;
    rules?: Ref<Rule<T>[]>;
    defaultRules?: Ref<Rule<T>[]>;
    noDefaultRules?: Ref<boolean>;
    state?: Ref<UIState>;
    callbacks?: {
        onBeforeMount?: () => void;
        onMounted?: () => void;
        onChange?: (newValue: T, oldValue: T) => void;
        onClear?: () => void;
        onBeforeUnmount?: () => void;
        onUnmounted?: () => void;
    };
}

export declare const inputOptionPropsArgTypes: {
    options: {
        control: any;
        table: {
            category: string;
        };
    };
    optionLabel: {
        control: any;
        table: {
            category: string;
        };
    };
    optionValue: {
        control: any;
        table: {
            category: string;
        };
    };
};

export declare const inputPropsArgTypes: {
    disabled: {
        control: any;
        table: {
            category: string;
        };
    };
    hidden: {
        control: any;
        table: {
            category: string;
        };
    };
    id: {
        control: any;
        table: {
            category: string;
        };
    };
    label: {
        control: any;
        table: {
            category: string;
        };
    };
    noLabel: {
        control: any;
        table: {
            category: string;
        };
    };
    noMessages: {
        control: any;
        table: {
            category: string;
        };
    };
    required: {
        control: any;
        table: {
            category: string;
        };
    };
    messages: {
        control: any;
        table: {
            category: string;
        };
    };
    name: {
        control: any;
        table: {
            category: string;
        };
    };
    noDefaultRules: {
        control: any;
        table: {
            category: string;
        };
    };
    placeholder: {
        control: any;
        table: {
            category: string;
        };
    };
    readonly: {
        control: any;
        table: {
            category: string;
        };
    };
    rules: {
        control: any;
        table: {
            category: string;
        };
    };
    state: {
        control: any;
        options: string[];
        table: {
            category: string;
        };
    };
    changed: {
        control: any;
        table: {
            category: string;
        };
    };
    valid: {
        control: any;
        table: {
            category: string;
        };
    };
};

declare interface InputPropsDefinition<T = unknown> extends InputWrapperPropsDefinition {
    messages: {
        type: PropType<Message<T>[]>;
        default: () => Message<T>[];
    };
    name: {
        type: typeof String;
        default: string;
    };
    noDefaultRules: {
        type: typeof Boolean;
        default: boolean;
    };
    placeholder: {
        type: typeof String;
        default: string;
    };
    readonly: {
        type: typeof Boolean;
        default: boolean;
    };
    rules: {
        type: PropType<Rule<T>[]>;
        default: () => Rule<T>[];
    };
    state: {
        type: PropType<UIState>;
        default: UIState;
    };
    changed: {
        type: typeof Boolean;
        default: boolean;
    };
    valid: {
        type: typeof Boolean;
        default: boolean;
    };
}

declare interface InputWrapperPropsDefinition {
    disabled: {
        type: typeof Boolean;
        default: boolean;
    };
    hidden: {
        type: typeof Boolean;
        default: boolean;
    };
    id: {
        type: typeof String;
        default: string;
    };
    label: {
        type: typeof String;
        default: string;
    };
    noLabel: {
        type: typeof Boolean;
        default: boolean;
    };
    noMessages: {
        type: typeof Boolean;
        default: boolean;
    };
    required: {
        type: typeof Boolean;
        default: boolean;
    };
}

declare type IsAny<T> = 0 extends 1 & T ? true : false;

declare function isVsTableBodyRow(row: VsTableCell[]): row is VsTableBodyCell[];

declare type Join<Prev extends string, K extends string, Sep extends string> = Prev extends ''
    ? K
    : `${Prev}${Sep}${K}`;

declare type JoinDotField<T> = JoinField<T, '.'>;

declare type JoinField<T, Sep extends string, Prev extends string = ''> = keyof T extends never
    ? string
    : {
          [K in Extract<keyof T, string>]: IsAny<T[K]> extends true
              ? Join<Prev, K, Sep>
              : T[K] extends Record<string, any>
                ? Join<Prev, K, Sep> | JoinField<T[K], Sep, Join<Prev, K, Sep>>
                : Join<Prev, K, Sep>;
      }[Extract<keyof T, string>];

export declare const LAYOUT_PROVIDED_KEY = 'vlossom:layout-provided';

export declare const LAYOUT_STORE_KEY = 'vlossom:layout-store';

export declare class LayoutStore {
    private _header;
    private _footer;
    private _drawers;
    static getDefaultLayoutStore(): LayoutStore;
    header: ComputedRef<BarLayout>;
    setHeader(layout: BarLayout): void;
    footer: ComputedRef<BarLayout>;
    setFooter(layout: BarLayout): void;
    drawers: ComputedRef<DrawerLayouts>;
    setDrawers(layouts: DrawerLayouts): void;
    setDrawer(layout: DrawerLayout): void;
}

export declare const logUtil: {
    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;
};

export declare const LOREM_IPSUM =
    '\nLorem ipsum dolor sit amet, consectetuer adipiscing elit.\nAenean commodo ligula eget dolor. Aenean massa.\nCum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.\nDonec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim.\nDonec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu.\nIn enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo.\nNullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibus.';

export declare type Message<T = any> = ValueOrFunction<T, StateMessage>;

export declare const minMaxArgTypes: {
    min: {
        control: any;
        table: {
            category: string;
        };
    };
    max: {
        control: any;
        table: {
            category: string;
        };
    };
};

declare interface ModalInfo extends ModalOptions {
    container: string;
    id: string;
    content: string | Component;
}

declare interface ModalOptions {
    beforeClose?: () => Promise<boolean> | boolean;
    container?: string;
    colorScheme?: ColorScheme;
    styleSet?: string | VsModalNodeStyleSet;
    callbacks?: OverlayCallbacks;
    dimClose?: boolean;
    dimmed?: boolean;
    escClose?: boolean;
    focusLock?: boolean;
    hideScroll?: boolean;
    id?: string;
    scrollLock?: boolean | string;
    componentProps?: Record<string, any>;
    size?:
        | SizeProp
        | {
              width?: SizeProp;
              height?: SizeProp;
          };
}

declare interface ModalPlugin {
    open(content: string, options?: Omit<ModalOptions, 'componentProps'>): string;
    open(content: Component, options?: ModalOptions): string;
    emit(eventName: string, ...args: any[]): void | Promise<void>;
    emitWithId(id: string, eventName: string, ...args: any[]): void | Promise<void>;
    close(container?: string): Promise<boolean>;
    closeWithId(id: string): Promise<boolean>;
    clear(container?: string): void;
}

export declare const modes: {
    light: {
        backgrounds: {
            value: string;
        };
    };
    dark: {
        backgrounds: {
            value: string;
        };
    };
    mobile: {
        viewport: string;
    };
    tablet: {
        viewport: string;
    };
    desktop: {
        viewport: string;
    };
};

export declare function mountOverlayApp(parentApp: App): void;

export declare const NOT_SELECTED = -1;

export declare const numberUtil: {
    clamp(value: number, min: number, max: number): number;
};

export declare const objectUtil: {
    assign: <X extends Record<string | number | symbol, any>>(initial: X, override: X) => X;
    clone: <T>(obj: T) => T;
    crush: <TValue extends object>(value: TValue) => object;
    get: <TDefault = unknown>(value: any, path: string, defaultValue?: TDefault | undefined) => TDefault;
    isEmpty: (value: any) => boolean;
    isEqual: <TType>(x: TType, y: TType) => boolean;
    isObject: (value: any) => value is object;
    omit: <T, TKeys extends keyof T>(obj: T, keys: TKeys[]) => Omit<T, TKeys>;
    shake: <RemovedKeys extends string, T>(obj: T, filter?: (value: any) => boolean) => Omit<T, RemovedKeys>;
};

export declare interface OptionItem {
    id: string;
    item: any;
    label: string;
    value: any;
    index: number;
    disabled: boolean;
}

export declare class OptionsStore {
    private _colorScheme;
    private _styleSet;
    private _theme;
    private _radiusRatio;
    colorScheme: ComputedRef<GlobalColorSchemes>;
    setColorScheme(colorScheme: GlobalColorSchemes): void;
    styleSet: ComputedRef<GlobalStyleSets>;
    setStyleSet(styleSet: GlobalStyleSets): void;
    theme: ComputedRef<Theme>;
    setTheme(theme: Theme): void;
    radiusRatio: ComputedRef<number>;
    setRadiusRatio(radiusRatio: number): void;
    getComponentStyleSet<
        T extends {
            [key: string]: any;
        },
    >(styleSetName: string, component: VsComponent | string): Partial<T>;
}

export declare const OVERLAY_CLOSE = 'vlossom:overlay-close';

export declare const OVERLAY_OPEN = 'vlossom:overlay-open';

export declare type OverlayCallbacks<T = void> = {
    [eventName: string]: (...args: any[]) => T | Promise<T>;
};

export declare class OverlayCallbackStore {
    private _overlays;
    overlays: Readonly<
        Ref<
            readonly (readonly [
                string,
                Readonly<
                    Ref<
                        {
                            readonly [x: string]: (...args: any[]) => void | Promise<void>;
                        },
                        {
                            readonly [x: string]: (...args: any[]) => void | Promise<void>;
                        }
                    >
                >,
            ])[],
            readonly (readonly [
                string,
                Readonly<
                    Ref<
                        {
                            readonly [x: string]: (...args: any[]) => void | Promise<void>;
                        },
                        {
                            readonly [x: string]: (...args: any[]) => void | Promise<void>;
                        }
                    >
                >,
            ])[]
        >
    >;
    constructor();
    private addOverlayCallbackKeyEventListener;
    getLastOverlay(): [string, Ref<OverlayCallbacks>] | null;
    getLastOverlayId(): string;
    run<T = void>(id: string, eventName: string, ...args: any[]): Promise<T | void>;
    push(id: string, callbacks: Ref<OverlayCallbacks>): Promise<void>;
    pop(...args: any[]): Promise<void> | undefined;
    remove(id: string, ...args: any[]): Promise<void> | undefined;
    clear(...args: any[]): void;
}

export declare class OverlayContainerStore {
    private _overlayViewMap;
    overlayViewMap: Readonly<Ref<Map<string, OverlayView>>>;
    push(id: string, container: string, component: string | Component): void;
    clear(): void;
    delete(id: string): void;
}

export declare interface OverlayStyle {
    width?: string;
    height?: string;
    pointerEvents?: string;
    zIndex?: number;
}

export declare type OverlayTuple = [string, Ref<OverlayCallbacks>];

export declare type OverlayView = {
    container: string;
    component: string | Component;
};

export declare type Placement = (typeof PLACEMENTS)[number];

export declare const PLACEMENTS: readonly ['top', 'right', 'bottom', 'left', 'middle'];

export declare const PROMPT_CANCEL = 'vlossom:prompt-cancel';

export declare const PROMPT_OK = 'vlossom:prompt-ok';

declare interface PromptModalOptions extends Omit<ModalOptions, 'beforeClose'> {
    styleSet?: VsPromptStyleSet;
    colorScheme?: ColorScheme;
    input?: PropsOf<VsComponent.VsInput> & {
        initialValue?: VsInputValueType;
    };
    okText?: string;
    cancelText?: string;
    swapButtons?: boolean;
}

declare interface PromptPlugin {
    open(content: string, options?: Omit<PromptModalOptions, 'componentProps'>): Promise<VsInputValueType>;
    open(content: Component, options?: PromptModalOptions): Promise<VsInputValueType>;
}

export declare type PropsOf<K extends keyof VsComponentRegistry> = InstanceType<VsComponentRegistry[K]>['$props'];

export declare const propsUtil: {
    checkValidNumber(componentName: string, property: string, value: number | string): boolean;
};

export declare const responsiveArgTypes: {
    width: {
        control: any;
        table: {
            category: string;
        };
    };
    grid: {
        control: any;
        table: {
            category: string;
        };
    };
};

export declare type Rule<T = any> = ((v: T) => string) | ((v: T) => PromiseLike<string>);

export declare class ScrollLockStore {
    private _locks;
    lock(ownerId: string, element: HTMLElement): void;
    unlock(ownerId: string, element: HTMLElement): void;
    clear(): void;
    private _capture;
    private _apply;
    private _restore;
}

export declare const scrollShadow: Directive<HTMLElement, boolean | undefined>;

export declare type SearchProps =
    | boolean
    | {
          useRegex?: boolean;
          useCaseSensitive?: boolean;
          placeholder?: string;
      };

export declare type Size = (typeof SIZES)[number];

export declare type SizeProp = Size | string | number;

export declare const SIZES: readonly ['xs', 'sm', 'md', 'lg', 'xl'];

export declare type SlotsOf<K extends keyof VsComponentRegistry> = InstanceType<VsComponentRegistry[K]>['$slots'];

export declare interface StateMessage<T extends string = UIState> {
    state: T;
    text: string;
}

export declare interface StringModifiers {
    capitalize?: boolean;
    lower?: boolean;
    upper?: boolean;
}

export declare const stringUtil: {
    createID(size?: number): string;
    convertToString(value: any): string;
    toStringSize(value: number | string): string;
    toFileSizeFormat(bytes: number): string;
    hash(str: string): string;
    kebabCase: typeof kebabCase;
};

export declare const styleArgTypes: {
    styleSet: {
        control: any;
        table: {
            category: string;
        };
    };
};

export declare const TABLE_COLOR_SCHEME_TOKEN: unique symbol;

export declare const TABLE_SIZE_TOKEN: unique symbol;

export declare const TABLE_STYLE_SET_TOKEN: unique symbol;

declare type TableComposable = {
    columns: ComputedRef<VsTableColumnDef[] | null>;
    items: Ref<VsTableItem[]>;
    headerCells: Ref<VsTableHeaderCell[]>;
    bodyCells: ComputedRef<VsTableBodyCell[][]>;
    gridTemplateColumns: ComputedRef<string>;
    anyExpandable: ComputedRef<boolean>;
    anySelectable: ComputedRef<boolean>;
    selectedItems: Ref<VsTableItem[]>;
    selectedAll: ComputedRef<boolean>;
    selectedPartial: ComputedRef<boolean>;
    selectable: ComputedRef<(item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean>;
    expandable: ComputedRef<(item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean>;
    state: ComputedRef<(item: VsTableItem, index?: number, items?: VsTableItem[]) => UIState>;
    sortType: Ref<VsTableSortType>;
    sortColumn: Ref<VsTableColumnDef | null>;
    loading: Ref<boolean | undefined> | undefined;
    draggable: Ref<boolean | undefined> | undefined;
    primary: Ref<boolean | undefined> | undefined;
    size: Ref<Size | undefined> | undefined;
    search: ComputedRef<Exclude<SearchProps, boolean>>;
    pagination: ComputedRef<VsTablePaginationOptions>;
    page: WritableComputedRef<number>;
    pageSize: WritableComputedRef<number>;
    totalPages: ComputedRef<number>;
    totalItems: ComputedRef<number>;
    pageStartIndex: ComputedRef<number>;
    pageEndIndex: ComputedRef<number>;
    isExpanded: (row: VsTableCell[]) => boolean;
    toggleExpand: (row: VsTableCell[]) => boolean;
    setExpand: (row: VsTableCell[], shouldExpand: boolean) => boolean;
    updateSortType: (headerKey: string) => void;
    initialize: () => void;
    toggleSelectAll: () => void;
};

export declare const TEXT_ALIGNMENTS: readonly ['left', 'center', 'right'];

export declare type TextAlignment = (typeof TEXT_ALIGNMENTS)[number];

export declare type Theme = 'light' | 'dark';

export declare const THEME_KEY = 'vlossom:theme-mode';

declare interface ToastInfo extends ToastOptions {
    container: string;
    id: string;
    content: string | Component;
}

declare interface ToastOptions {
    container?: string;
    colorScheme?: ColorScheme;
    styleSet?: string | VsToastStyleSet;
    align?: Alignment;
    autoClose?: boolean;
    placement?: Exclude<Placement, 'left' | 'right'>;
    primary?: boolean;
    timeout?: number;
    logger?: (message: string | Component) => string;
}

declare interface ToastPlugin {
    show(message: string | Component, options?: ToastOptions): void;
    info(message: string | Component, options?: ToastOptions): void;
    success(message: string | Component, options?: ToastOptions): void;
    warning(message: string | Component, options?: ToastOptions): void;
    error(message: string | Component, options?: ToastOptions): void;
    remove(container: string, id: string): void;
    clear(container?: string): void;
}

/**
 * NOTE: ex. If type is TResult | ((...args: TArgs) => TResult), return "the only" function that returns the TResult.
 */
declare function toCallable<TArgs extends any[] = [], TResult = boolean>(
    maybeFn: undefined | TResult | ((...args: TArgs) => TResult),
): (...args: TArgs) => TResult;

export declare type UIState = 'idle' | 'success' | 'info' | 'error' | 'warning';

export declare function useClickOutside(
    excludedSelectors: string[],
    callback: () => void,
): {
    addClickOutsideListener: () => void;
    removeClickOutsideListener: () => void;
};

export declare function useColorScheme(
    component: VsComponent | string,
    colorScheme: Ref<ColorScheme | undefined>,
): {
    computedColorScheme: ComputedRef<
        | 'brown'
        | 'red'
        | 'orange'
        | 'amber'
        | 'yellow'
        | 'lime'
        | 'green'
        | 'emerald'
        | 'teal'
        | 'cyan'
        | 'sky'
        | 'blue'
        | 'indigo'
        | 'violet'
        | 'purple'
        | 'fuchsia'
        | 'pink'
        | 'rose'
        | 'gray'
        | 'none'
        | undefined
    >;
    colorSchemeClass: ComputedRef<string>;
};

export declare function useFocusable(wrapperElement: TemplateRef<HTMLElement>): {
    focusIndex: DeepReadonly<Ref<number>>;
    currentFocusableElement: DeepReadonly<Ref<HTMLElement | null>>;
    updateFocusIndex: (index: number) => void;
    getFocusableElements: () => HTMLElement[];
    addMouseMoveListener: () => void;
    removeMouseMoveListener: () => void;
};

export declare function useIndexSelector(
    list: Ref<any[]>,
    disabled?: Ref<boolean | ((item: any, index: number) => boolean) | undefined>,
): {
    selectedIndex: Ref<number, number>;
    isSelected: (index: number) => boolean;
    isDisabled: (index: number) => boolean;
    isAllDisabled: () => boolean;
    isPrevious: (index: number) => boolean;
    findActiveIndexForwardFrom: (targetIndex: number) => number;
    findActiveIndexBackwardFrom: (targetIndex: number) => number;
    selectIndex: (index: number) => void;
    syncIndex: (index: number) => void;
    handleKeydown: (e: KeyboardEvent, isVertical: boolean) => void;
    isFirstEdge: ComputedRef<boolean>;
    isLastEdge: ComputedRef<boolean>;
};

export declare function useInput<T = unknown>(
    ctx: any,
    inputParams: InputComponentParams<T>,
): {
    changed: ComputedRef<boolean>;
    valid: ComputedRef<boolean>;
    shake: Ref<boolean, boolean>;
    computedMessages: ComputedRef<StateMessage<UIState>[]>;
    showRuleMessages: Ref<boolean, boolean>;
    validate: () => boolean;
    clear: () => void;
    reset: () => void;
    computedId: ComputedRef<string>;
    computedDisabled: ComputedRef<boolean>;
    computedReadonly: ComputedRef<boolean>;
    computedState: ComputedRef<UIState>;
};

export declare function useInputForm(
    id: Ref<string>,
    valid: Ref<boolean>,
    changed: Ref<boolean>,
    validate: () => boolean,
    clear: () => void,
    reset: () => void,
): {
    formDisabled: ComputedRef<boolean>;
    formReadonly: ComputedRef<boolean>;
};

export declare function useInputMessages<T>(
    inputValue: Ref<T>,
    messages: Ref<Message<T>[]>,
    ruleMessages: Ref<StateMessage[]>,
): {
    showRuleMessages: Ref<boolean, boolean>;
    computedMessages: ComputedRef<StateMessage<UIState>[]>;
    checkMessages: () => Promise<void>;
};

export declare function useInputOption(
    inputValue: Ref<any>,
    options: Ref<any[]>,
    optionLabel: Ref<string>,
    optionValue: Ref<string>,
    multiple?: Ref<boolean, boolean>,
): {
    getOptionLabel: (option: any) => string;
    getOptionValue: (option: any) => any;
};

export declare function useInputRules<T>(
    inputValue: Ref<T>,
    rules: Ref<Rule<T>[]>,
    defaultRules: Ref<Rule<T>[]>,
    noDefaultRules: Ref<boolean>,
): {
    ruleMessages: Ref<StateMessage<UIState>[], StateMessage<UIState>[]>;
    checkRules: () => Promise<void>;
};

export declare function useLayoutChild(layoutProp: Ref<boolean>): {
    isLayoutChild: ComputedRef<boolean>;
};

export declare function useModalContainerStore(): ContainerStore<ModalInfo>;

export declare function useOptionLabelValue(
    optionLabel: Ref<string>,
    optionValue: Ref<string>,
): {
    getOptionLabel: (option: any) => string;
    getOptionValue: (option: any) => any;
};

export declare function useOptionList(
    options: Ref<any[]>,
    optionLabel: Ref<string>,
    optionValue: Ref<string>,
    disabled: Ref<boolean | ((option: any, index: number, options: any[]) => boolean)>,
): {
    computedOptions: ComputedRef<
        {
            id: string;
            item: any;
            label: string;
            value: any;
            index: number;
            disabled: boolean;
        }[]
    >;
};

export declare function useOptionsStore(): OptionsStore;

export declare function useOverlayCallback(
    id: Ref<string>,
    callbacks?: Ref<OverlayCallbacks>,
): {
    overlayId: ComputedRef<string>;
    isActivated: Ref<boolean, boolean>;
    isUnmounting: Ref<boolean, boolean>;
    activate: () => void;
    deactivate: () => void;
};

export declare function useOverlayCallbackStore(): OverlayCallbackStore;

export declare function useOverlayContainerStore(): OverlayContainerStore;

export declare function useOverlayDom(): {
    appendOverlayDom: (targetElement: Element, overlayId: string, overlayStyle?: OverlayStyle) => Element;
};

export declare function usePositioning(
    target: string,
    attachment: TemplateRef<HTMLElement>,
): {
    isVisible: Ref<boolean, boolean>;
    computedPlacement: Ref<
        'top' | 'right' | 'bottom' | 'left' | 'middle' | null,
        'top' | 'right' | 'bottom' | 'left' | 'middle' | null
    >;
    appear: (attachInfo?: AttachInfo) => void;
    disappear: () => void;
};

export declare function useScrollLock(container?: string): {
    isLocked: Ref<boolean, boolean>;
    lock: () => void;
    unlock: () => void;
};

export declare function useScrollLockStore(): ScrollLockStore;

export declare function useSizeClass(size: Ref<Size | undefined>): {
    sizeClass: ComputedRef<string>;
};

export declare function useStateClass(state: Ref<UIState>): {
    isStated: ComputedRef<boolean>;
    stateClasses: ComputedRef<
        | {
              'vs-stated'?: undefined;
          }
        | {
              [x: string]: true;
              'vs-stated': true;
          }
    >;
    stateBoxClasses: ComputedRef<{}>;
};

export declare function useStringModifier(modifiers: Ref<StringModifiers>): {
    modifyStringValue: (value: string) => string;
};

export declare function useStyleSet<
    T extends {
        [key: string]: any;
    },
>(
    component: VsComponent | string,
    styleSet: Ref<string | T | undefined>,
    baseStyleSet?: Ref<Partial<T>>,
    additionalStyleSet?: Ref<Partial<T>>,
): {
    componentStyleSet: ComputedRef<Partial<T>>;
    styleSetVariables: ComputedRef<Record<string, string>>;
    componentInlineStyle: ComputedRef<CSSProperties>;
};

export declare function useToastContainerStore(): ContainerStore<ToastInfo>;

export declare function useValueMatcher(
    multiple: Ref<boolean>,
    inputValue: Ref<any>,
    trueValue: Ref<any>,
    falseValue: Ref<any>,
): {
    isMatched: ComputedRef<boolean>;
    getInitialValue: () => any;
    getUpdatedValue: (isTruthy: boolean) => any;
    getClearedValue: () => any;
    addTrueValue: () => void;
};

export declare function useVlossom(): Vlossom;

export declare type ValueOrFunction<T = any, V = any> = V | ((value: T) => V) | ((value: T) => PromiseLike<V>);

export declare const VERTICAL_ALIGNMENTS: readonly ['top', 'middle', 'bottom'];

export declare type VerticalAlignment = (typeof VERTICAL_ALIGNMENTS)[number];

export declare class Vlossom {
    private _optionsStore;
    private _toast;
    private _modal;
    private _alert;
    private _confirm;
    private _prompt;
    constructor(options: VlossomOptions);
    get toast(): ToastPlugin;
    get modal(): ModalPlugin;
    get alert(): AlertPlugin;
    get confirm(): ConfirmPlugin;
    get prompt(): PromptPlugin;
    set colorScheme(colorScheme: GlobalColorSchemes);
    get colorScheme(): GlobalColorSchemes;
    set styleSet(styleSet: GlobalStyleSets);
    get styleSet(): GlobalStyleSets;
    set theme(theme: Theme);
    get theme(): Theme;
    set radiusRatio(radiusRatio: number);
    get radiusRatio(): number;
    toggleTheme(): void;
    private setDefaultTheme;
}

/**
 * 모든 Vlossom 컴포넌트를 포함하는 컴포넌트 맵
 *
 * ⚠️ 주의: 이 객체를 application에서 import하면 모든 Vlossom 컴포넌트가 번들에 포함됩니다.
 * Tree shaking 최적화가 필요한 경우 개별 컴포넌트만 import하세요.
 */
export declare const VlossomComponents: {
    readonly VsAccordion: DefineComponent<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            open: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsAccordionStyleSet>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentStyleSet: ComputedRef<Partial<VsAccordionStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            isOpen: Ref<boolean, boolean>;
            classObj: ComputedRef<{
                [x: string]: boolean;
                'vs-focus-visible': boolean;
                'vs-disabled': boolean;
                'vs-primary': boolean;
            }>;
            toggle: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('toggle' | 'update:modelValue')[],
        'toggle' | 'update:modelValue',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                open: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsAccordionStyleSet>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onToggle?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            disabled: boolean;
            open: boolean;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            primary: boolean;
            modelValue: boolean;
        },
        {},
        {
            VsResponsive: DefineComponent<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    responsiveClasses: ComputedRef<string[]>;
                    responsiveStyles: ComputedRef<Record<string, string>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsExpandable: DefineComponent<
                ExtractPropTypes<{
                    open: {
                        type: BooleanConstructor;
                        required: true;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsExpandableStyleSet>;
                    };
                }>,
                {
                    sizeClass: ComputedRef<string>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    beforeEnter: (el: Element) => void;
                    enter: (el: Element, done: () => void) => void;
                    beforeLeave: (el: Element) => void;
                    leave: (el: Element, done: () => void) => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        open: {
                            type: BooleanConstructor;
                            required: true;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsExpandableStyleSet>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsAvatar: DefineComponent<
        ExtractPropTypes<{
            styleSet: {
                type: PropType<string | VsAvatarStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                styleSet: {
                    type: PropType<string | VsAvatarStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {},
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsBar: DefineComponent<
        ExtractPropTypes<{
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            position: {
                type: PropType<CssPosition>;
            };
            styleSet: {
                type: PropType<string | VsBarStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                'vs-primary': boolean;
            }>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                position: {
                    type: PropType<CssPosition>;
                };
                styleSet: {
                    type: PropType<string | VsBarStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {
            tag: string;
            primary: boolean;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsButton: DefineComponent<
        ExtractPropTypes<{
            circle: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            ghost: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            type: {
                type: PropType<'button' | 'submit' | 'reset'>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsButtonStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                [x: string]: boolean;
                'vs-focus-visible': boolean;
                'vs-circle': boolean;
                'vs-disabled': boolean;
                'vs-ghost': boolean;
                'vs-loading-state': boolean;
                'vs-outline': boolean;
                'vs-primary': boolean;
                'vs-responsive': boolean;
            }>;
            buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
            componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                circle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<'button' | 'submit' | 'reset'>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsButtonStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {
            circle: boolean;
            disabled: boolean;
            type: 'button' | 'reset' | 'submit';
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            outline: boolean;
            primary: boolean;
            ghost: boolean;
            loading: boolean;
            responsive: boolean;
        },
        {},
        {
            VsLoading: DefineComponent<
                ExtractPropTypes<{
                    width: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    styleSet: {
                        type: PropType<string | VsLoadingStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        width: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        styleSet: {
                            type: PropType<string | VsLoadingStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {},
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsBlock: DefineComponent<
        ExtractPropTypes<{
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            styleSet: {
                type: PropType<string | VsBlockStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsBlockStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                styleSet: {
                    type: PropType<string | VsBlockStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>
        > &
            Readonly<{}>,
        {},
        {},
        {
            VsResponsive: DefineComponent<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    responsiveClasses: ComputedRef<string[]>;
                    responsiveStyles: ComputedRef<Record<string, string>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsInnerScroll: DefineComponent<
                ExtractPropTypes<{
                    hideScroll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInnerScrollStyleSet>;
                    };
                }>,
                {
                    componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    hasScroll: () => boolean;
                    bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        hideScroll: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInnerScrollStyleSet>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    hideScroll: boolean;
                },
                {},
                {},
                {
                    scrollShadow: Directive<HTMLElement, boolean | undefined>;
                },
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsCheckbox: DefineComponent<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                default: null;
            };
            checked: {
                type: BooleanConstructor;
                default: boolean;
            };
            checkLabel: {
                type: StringConstructor;
                default: string;
            };
            indeterminate: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            trueValue: {
                type: null;
                default: boolean;
            };
            falseValue: {
                type: null;
                default: boolean;
            };
            modelValue: {
                type: null;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsCheckboxStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                'vs-checked': boolean;
                'vs-disabled': boolean;
                'vs-focus-visible': boolean;
                'vs-indeterminate': boolean;
                'vs-readonly': boolean;
            }>;
            sizeClass: ComputedRef<string>;
            stateBoxClasses: ComputedRef<{}>;
            computedId: ComputedRef<string>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            computedState: ComputedRef<UIState>;
            convertToString: (value: any) => string;
            inputValue: Ref<any, any>;
            isChecked: ComputedRef<boolean>;
            shake: Ref<boolean, boolean>;
            toggle: (e: MouseEvent) => Promise<void>;
            onFocus: (e: FocusEvent) => void;
            onBlur: (e: FocusEvent) => void;
            validate: () => boolean;
            clear: () => void;
            reset: () => void;
            focus: () => void;
            blur: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
        'blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                beforeChange: {
                    type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                    default: null;
                };
                checked: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                checkLabel: {
                    type: StringConstructor;
                    default: string;
                };
                indeterminate: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                trueValue: {
                    type: null;
                    default: boolean;
                };
                falseValue: {
                    type: null;
                    default: boolean;
                };
                modelValue: {
                    type: null;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<any>[]>;
                    default: () => Message<any>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<any>[]>;
                    default: () => Rule<any>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsCheckboxStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                onToggle?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            messages: Message<any>[];
            name: string;
            noDefaultRules: boolean;
            readonly: boolean;
            rules: Rule<any>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            multiple: boolean;
            modelValue: any;
            beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
            checked: boolean;
            checkLabel: string;
            indeterminate: boolean;
            trueValue: any;
            falseValue: any;
        },
        {},
        {
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsCheckboxSet: DefineComponent<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                default: null;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: PropType<any[]>;
                default: () => never[];
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            options: {
                type: PropType<any[]>;
                default: () => never[];
            };
            optionLabel: {
                type: StringConstructor;
                default: string;
            };
            optionValue: {
                type: StringConstructor;
                default: string;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any[]>[]>;
                default: () => Message<any[]>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any[]>[]>;
                default: () => Rule<any[]>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsCheckboxSetStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            checkboxRefs: Readonly<
                ShallowRef<
                    | CreateComponentPublicInstanceWithMixins<
                          Readonly<
                              ExtractPropTypes<{
                                  beforeChange: {
                                      type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                      default: null;
                                  };
                                  checked: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  checkLabel: {
                                      type: StringConstructor;
                                      default: string;
                                  };
                                  indeterminate: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  multiple: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  size: {
                                      type: PropType<Size>;
                                      default: string;
                                  };
                                  trueValue: {
                                      type: null;
                                      default: boolean;
                                  };
                                  falseValue: {
                                      type: null;
                                      default: boolean;
                                  };
                                  modelValue: {
                                      type: null;
                                      default: boolean;
                                  };
                                  width: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  grid: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  label: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  messages: {
                                      type: PropType<Message<any>[]>;
                                      default: () => Message<any>[];
                                  };
                                  name: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noDefaultRules: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  readonly: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  rules: {
                                      type: PropType<Rule<any>[]>;
                                      default: () => Rule<any>[];
                                  };
                                  state: {
                                      type: PropType<UIState>;
                                      default: UIState;
                                  };
                                  changed: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  valid: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  disabled: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  hidden: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  id: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noLabel: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  noMessages: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  required: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  styleSet: {
                                      type: PropType<string | VsCheckboxStyleSet>;
                                  };
                                  colorScheme: {
                                      type: PropType<ColorScheme>;
                                  };
                              }>
                          > &
                              Readonly<{
                                  onFocus?: ((...args: any[]) => any) | undefined;
                                  onBlur?: ((...args: any[]) => any) | undefined;
                                  onChange?: ((...args: any[]) => any) | undefined;
                                  onToggle?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                  onClear?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                              }>,
                          {
                              checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                              colorSchemeClass: ComputedRef<string>;
                              componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                              styleSetVariables: ComputedRef<Record<string, string>>;
                              componentInlineStyle: ComputedRef<CSSProperties>;
                              classObj: ComputedRef<{
                                  'vs-checked': boolean;
                                  'vs-disabled': boolean;
                                  'vs-focus-visible': boolean;
                                  'vs-indeterminate': boolean;
                                  'vs-readonly': boolean;
                              }>;
                              sizeClass: ComputedRef<string>;
                              stateBoxClasses: ComputedRef<{}>;
                              computedId: ComputedRef<string>;
                              computedDisabled: ComputedRef<boolean>;
                              computedReadonly: ComputedRef<boolean>;
                              computedMessages: ComputedRef<StateMessage<UIState>[]>;
                              computedState: ComputedRef<UIState>;
                              convertToString: (value: any) => string;
                              inputValue: Ref<any, any>;
                              isChecked: ComputedRef<boolean>;
                              shake: Ref<boolean, boolean>;
                              toggle: (e: MouseEvent) => Promise<void>;
                              onFocus: (e: FocusEvent) => void;
                              onBlur: (e: FocusEvent) => void;
                              validate: () => boolean;
                              clear: () => void;
                              reset: () => void;
                              focus: () => void;
                              blur: () => void;
                          },
                          {},
                          {},
                          {},
                          ComponentOptionsMixin,
                          ComponentOptionsMixin,
                          (
                              | 'blur'
                              | 'change'
                              | 'focus'
                              | 'toggle'
                              | 'clear'
                              | 'update:modelValue'
                              | 'update:changed'
                              | 'update:valid'
                          )[],
                          PublicProps,
                          {
                              label: string;
                              messages: Message<any>[];
                              name: string;
                              noDefaultRules: boolean;
                              readonly: boolean;
                              rules: Rule<any>[];
                              state: UIState;
                              changed: boolean;
                              valid: boolean;
                              disabled: boolean;
                              hidden: boolean;
                              id: string;
                              noLabel: boolean;
                              noMessages: boolean;
                              required: boolean;
                              size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                              multiple: boolean;
                              modelValue: any;
                              beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                              checked: boolean;
                              checkLabel: string;
                              indeterminate: boolean;
                              trueValue: any;
                              falseValue: any;
                          },
                          true,
                          {},
                          {},
                          {
                              VsInputWrapper: DefineComponent<
                                  ExtractPropTypes<{
                                      groupLabel: {
                                          type: BooleanConstructor;
                                          default: boolean;
                                      };
                                      messages: {
                                          type: PropType<StateMessage<UIState>[]>;
                                          default: () => never[];
                                      };
                                      shake: {
                                          type: BooleanConstructor;
                                          default: boolean;
                                      };
                                      styleSet: {
                                          type: PropType<string | VsInputWrapperStyleSet>;
                                      };
                                      disabled: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      hidden: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      id: {
                                          type: typeof String;
                                          default: string;
                                      };
                                      label: {
                                          type: typeof String;
                                          default: string;
                                      };
                                      noLabel: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      noMessages: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      required: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      width: {
                                          type: PropType<string | number | Breakpoints>;
                                      };
                                      grid: {
                                          type: PropType<string | number | Breakpoints>;
                                      };
                                  }>,
                                  {
                                      needToShake: Ref<boolean, boolean>;
                                      componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                      componentInlineStyle: ComputedRef<CSSProperties>;
                                  },
                                  {},
                                  {},
                                  {},
                                  ComponentOptionsMixin,
                                  ComponentOptionsMixin,
                                  {},
                                  string,
                                  PublicProps,
                                  Readonly<
                                      ExtractPropTypes<{
                                          groupLabel: {
                                              type: BooleanConstructor;
                                              default: boolean;
                                          };
                                          messages: {
                                              type: PropType<StateMessage<UIState>[]>;
                                              default: () => never[];
                                          };
                                          shake: {
                                              type: BooleanConstructor;
                                              default: boolean;
                                          };
                                          styleSet: {
                                              type: PropType<string | VsInputWrapperStyleSet>;
                                          };
                                          disabled: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          hidden: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          id: {
                                              type: typeof String;
                                              default: string;
                                          };
                                          label: {
                                              type: typeof String;
                                              default: string;
                                          };
                                          noLabel: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          noMessages: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          required: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          width: {
                                              type: PropType<string | number | Breakpoints>;
                                          };
                                          grid: {
                                              type: PropType<string | number | Breakpoints>;
                                          };
                                      }>
                                  > &
                                      Readonly<{}>,
                                  {
                                      label: string;
                                      messages: StateMessage<UIState>[];
                                      disabled: boolean;
                                      hidden: boolean;
                                      id: string;
                                      noLabel: boolean;
                                      noMessages: boolean;
                                      required: boolean;
                                      groupLabel: boolean;
                                      shake: boolean;
                                  },
                                  {},
                                  {
                                      VsResponsive: DefineComponent<
                                          ExtractPropTypes<{
                                              tag: {
                                                  type: StringConstructor;
                                                  default: string;
                                              };
                                              width: {
                                                  type: PropType<string | number | Breakpoints>;
                                              };
                                              grid: {
                                                  type: PropType<string | number | Breakpoints>;
                                              };
                                          }>,
                                          {
                                              responsiveClasses: ComputedRef<string[]>;
                                              responsiveStyles: ComputedRef<Record<string, string>>;
                                          },
                                          {},
                                          {},
                                          {},
                                          ComponentOptionsMixin,
                                          ComponentOptionsMixin,
                                          {},
                                          string,
                                          PublicProps,
                                          Readonly<
                                              ExtractPropTypes<{
                                                  tag: {
                                                      type: StringConstructor;
                                                      default: string;
                                                  };
                                                  width: {
                                                      type: PropType<string | number | Breakpoints>;
                                                  };
                                                  grid: {
                                                      type: PropType<string | number | Breakpoints>;
                                                  };
                                              }>
                                          > &
                                              Readonly<{}>,
                                          {
                                              tag: string;
                                          },
                                          {},
                                          {},
                                          {},
                                          string,
                                          ComponentProvideOptions,
                                          true,
                                          {},
                                          any
                                      >;
                                      VsMessage: DefineComponent<
                                          ExtractPropTypes<{
                                              state: {
                                                  type: PropType<UIState>;
                                                  default: string;
                                              };
                                              text: {
                                                  type: StringConstructor;
                                                  default: string;
                                              };
                                              styleSet: {
                                                  type: PropType<string | VsMessageStyleSet>;
                                              };
                                          }>,
                                          {
                                              colorClass: ComputedRef<
                                                  | 'vs-cs-blue'
                                                  | 'vs-cs-green'
                                                  | 'vs-cs-amber'
                                                  | 'vs-cs-red'
                                                  | 'vs-cs-default'
                                              >;
                                              icon: ComputedRef<Component>;
                                              styleSetVariables: ComputedRef<Record<string, string>>;
                                              componentInlineStyle: ComputedRef<CSSProperties>;
                                          },
                                          {},
                                          {},
                                          {},
                                          ComponentOptionsMixin,
                                          ComponentOptionsMixin,
                                          {},
                                          string,
                                          PublicProps,
                                          Readonly<
                                              ExtractPropTypes<{
                                                  state: {
                                                      type: PropType<UIState>;
                                                      default: string;
                                                  };
                                                  text: {
                                                      type: StringConstructor;
                                                      default: string;
                                                  };
                                                  styleSet: {
                                                      type: PropType<string | VsMessageStyleSet>;
                                                  };
                                              }>
                                          > &
                                              Readonly<{}>,
                                          {
                                              text: string;
                                              state: UIState;
                                          },
                                          {},
                                          {},
                                          {},
                                          string,
                                          ComponentProvideOptions,
                                          true,
                                          {},
                                          any
                                      >;
                                  },
                                  {},
                                  string,
                                  ComponentProvideOptions,
                                  true,
                                  {},
                                  any
                              >;
                          } & GlobalComponents,
                          GlobalDirectives,
                          string,
                          {},
                          any,
                          ComponentProvideOptions,
                          {
                              P: {};
                              B: {};
                              D: {};
                              C: {};
                              M: {};
                              Defaults: {};
                          },
                          Readonly<
                              ExtractPropTypes<{
                                  beforeChange: {
                                      type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                      default: null;
                                  };
                                  checked: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  checkLabel: {
                                      type: StringConstructor;
                                      default: string;
                                  };
                                  indeterminate: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  multiple: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  size: {
                                      type: PropType<Size>;
                                      default: string;
                                  };
                                  trueValue: {
                                      type: null;
                                      default: boolean;
                                  };
                                  falseValue: {
                                      type: null;
                                      default: boolean;
                                  };
                                  modelValue: {
                                      type: null;
                                      default: boolean;
                                  };
                                  width: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  grid: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  label: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  messages: {
                                      type: PropType<Message<any>[]>;
                                      default: () => Message<any>[];
                                  };
                                  name: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noDefaultRules: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  readonly: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  rules: {
                                      type: PropType<Rule<any>[]>;
                                      default: () => Rule<any>[];
                                  };
                                  state: {
                                      type: PropType<UIState>;
                                      default: UIState;
                                  };
                                  changed: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  valid: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  disabled: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  hidden: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  id: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noLabel: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  noMessages: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  required: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  styleSet: {
                                      type: PropType<string | VsCheckboxStyleSet>;
                                  };
                                  colorScheme: {
                                      type: PropType<ColorScheme>;
                                  };
                              }>
                          > &
                              Readonly<{
                                  onFocus?: ((...args: any[]) => any) | undefined;
                                  onBlur?: ((...args: any[]) => any) | undefined;
                                  onChange?: ((...args: any[]) => any) | undefined;
                                  onToggle?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                  onClear?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                              }>,
                          {
                              checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                              colorSchemeClass: ComputedRef<string>;
                              componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                              styleSetVariables: ComputedRef<Record<string, string>>;
                              componentInlineStyle: ComputedRef<CSSProperties>;
                              classObj: ComputedRef<{
                                  'vs-checked': boolean;
                                  'vs-disabled': boolean;
                                  'vs-focus-visible': boolean;
                                  'vs-indeterminate': boolean;
                                  'vs-readonly': boolean;
                              }>;
                              sizeClass: ComputedRef<string>;
                              stateBoxClasses: ComputedRef<{}>;
                              computedId: ComputedRef<string>;
                              computedDisabled: ComputedRef<boolean>;
                              computedReadonly: ComputedRef<boolean>;
                              computedMessages: ComputedRef<StateMessage<UIState>[]>;
                              computedState: ComputedRef<UIState>;
                              convertToString: (value: any) => string;
                              inputValue: Ref<any, any>;
                              isChecked: ComputedRef<boolean>;
                              shake: Ref<boolean, boolean>;
                              toggle: (e: MouseEvent) => Promise<void>;
                              onFocus: (e: FocusEvent) => void;
                              onBlur: (e: FocusEvent) => void;
                              validate: () => boolean;
                              clear: () => void;
                              reset: () => void;
                              focus: () => void;
                              blur: () => void;
                          },
                          {},
                          {},
                          {},
                          {
                              label: string;
                              messages: Message<any>[];
                              name: string;
                              noDefaultRules: boolean;
                              readonly: boolean;
                              rules: Rule<any>[];
                              state: UIState;
                              changed: boolean;
                              valid: boolean;
                              disabled: boolean;
                              hidden: boolean;
                              id: string;
                              noLabel: boolean;
                              noMessages: boolean;
                              required: boolean;
                              size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                              multiple: boolean;
                              modelValue: any;
                              beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                              checked: boolean;
                              checkLabel: string;
                              indeterminate: boolean;
                              trueValue: any;
                              falseValue: any;
                          }
                      >[]
                    | null
                >
            >;
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsCheckboxSetStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                'vs-vertical': boolean;
                'vs-disabled': boolean;
                'vs-readonly': boolean;
            }>;
            sizeClass: ComputedRef<string>;
            computedId: ComputedRef<string>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            computedState: ComputedRef<UIState>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            checkboxStyleSet: ComputedRef<Omit<VsCheckboxStyleSet, '$wrapper'>>;
            shake: Ref<boolean, boolean>;
            inputValue: Ref<any[], any[]>;
            getOptionLabel: (option: any) => string;
            getOptionValue: (option: any) => any;
            onCheckboxUpdate: (value: any[]) => void;
            onFocus: (option: any, e: FocusEvent) => void;
            onBlur: (option: any, e: FocusEvent) => void;
            validate: () => boolean;
            clear: () => void;
            reset: () => void;
            focus: () => void;
            blur: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
        'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                beforeChange: {
                    type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                    default: null;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modelValue: {
                    type: PropType<any[]>;
                    default: () => never[];
                };
                min: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                max: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                options: {
                    type: PropType<any[]>;
                    default: () => never[];
                };
                optionLabel: {
                    type: StringConstructor;
                    default: string;
                };
                optionValue: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<any[]>[]>;
                    default: () => Message<any[]>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<any[]>[]>;
                    default: () => Rule<any[]>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsCheckboxSetStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            messages: Message<any[]>[];
            name: string;
            noDefaultRules: boolean;
            readonly: boolean;
            rules: Rule<any[]>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            min: string | number;
            max: string | number;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            vertical: boolean;
            modelValue: any[];
            beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
            options: any[];
            optionLabel: string;
            optionValue: string;
        },
        {},
        {
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsCheckbox: DefineComponent<
                ExtractPropTypes<{
                    beforeChange: {
                        type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                        default: null;
                    };
                    checked: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    checkLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    indeterminate: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    multiple: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    trueValue: {
                        type: null;
                        default: boolean;
                    };
                    falseValue: {
                        type: null;
                        default: boolean;
                    };
                    modelValue: {
                        type: null;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<any>[]>;
                        default: () => Message<any>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<any>[]>;
                        default: () => Rule<any>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsCheckboxStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    classObj: ComputedRef<{
                        'vs-checked': boolean;
                        'vs-disabled': boolean;
                        'vs-focus-visible': boolean;
                        'vs-indeterminate': boolean;
                        'vs-readonly': boolean;
                    }>;
                    sizeClass: ComputedRef<string>;
                    stateBoxClasses: ComputedRef<{}>;
                    computedId: ComputedRef<string>;
                    computedDisabled: ComputedRef<boolean>;
                    computedReadonly: ComputedRef<boolean>;
                    computedMessages: ComputedRef<StateMessage<UIState>[]>;
                    computedState: ComputedRef<UIState>;
                    convertToString: (value: any) => string;
                    inputValue: Ref<any, any>;
                    isChecked: ComputedRef<boolean>;
                    shake: Ref<boolean, boolean>;
                    toggle: (e: MouseEvent) => Promise<void>;
                    onFocus: (e: FocusEvent) => void;
                    onBlur: (e: FocusEvent) => void;
                    validate: () => boolean;
                    clear: () => void;
                    reset: () => void;
                    focus: () => void;
                    blur: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                (
                    | 'blur'
                    | 'change'
                    | 'focus'
                    | 'toggle'
                    | 'clear'
                    | 'update:modelValue'
                    | 'update:changed'
                    | 'update:valid'
                )[],
                | 'blur'
                | 'change'
                | 'focus'
                | 'toggle'
                | 'clear'
                | 'update:modelValue'
                | 'update:changed'
                | 'update:valid',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        beforeChange: {
                            type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                            default: null;
                        };
                        checked: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        checkLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        indeterminate: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        multiple: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        trueValue: {
                            type: null;
                            default: boolean;
                        };
                        falseValue: {
                            type: null;
                            default: boolean;
                        };
                        modelValue: {
                            type: null;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        messages: {
                            type: PropType<Message<any>[]>;
                            default: () => Message<any>[];
                        };
                        name: {
                            type: typeof String;
                            default: string;
                        };
                        noDefaultRules: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        readonly: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        rules: {
                            type: PropType<Rule<any>[]>;
                            default: () => Rule<any>[];
                        };
                        state: {
                            type: PropType<UIState>;
                            default: UIState;
                        };
                        changed: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        valid: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsCheckboxStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onChange?: ((...args: any[]) => any) | undefined;
                        onToggle?: ((...args: any[]) => any) | undefined;
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        onClear?: ((...args: any[]) => any) | undefined;
                        'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                        'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    label: string;
                    messages: Message<any>[];
                    name: string;
                    noDefaultRules: boolean;
                    readonly: boolean;
                    rules: Rule<any>[];
                    state: UIState;
                    changed: boolean;
                    valid: boolean;
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    multiple: boolean;
                    modelValue: any;
                    beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                    checked: boolean;
                    checkLabel: string;
                    indeterminate: boolean;
                    trueValue: any;
                    falseValue: any;
                },
                {},
                {
                    VsInputWrapper: DefineComponent<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            needToShake: Ref<boolean, boolean>;
                            componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                groupLabel: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                messages: {
                                    type: PropType<StateMessage<UIState>[]>;
                                    default: () => never[];
                                };
                                shake: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputWrapperStyleSet>;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            label: string;
                            messages: StateMessage<UIState>[];
                            disabled: boolean;
                            hidden: boolean;
                            id: string;
                            noLabel: boolean;
                            noMessages: boolean;
                            required: boolean;
                            groupLabel: boolean;
                            shake: boolean;
                        },
                        {},
                        {
                            VsResponsive: DefineComponent<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>,
                                {
                                    responsiveClasses: ComputedRef<string[]>;
                                    responsiveStyles: ComputedRef<Record<string, string>>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        tag: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    tag: string;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsMessage: DefineComponent<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>,
                                {
                                    colorClass: ComputedRef<
                                        'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                    >;
                                    icon: ComputedRef<Component>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        state: {
                                            type: PropType<UIState>;
                                            default: string;
                                        };
                                        text: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsMessageStyleSet>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    text: string;
                                    state: UIState;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsChip: DefineComponent<
        ExtractPropTypes<{
            closable: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsChipStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsChipStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                [x: string]: boolean;
                'vs-outline': boolean;
                'vs-primary': boolean;
            }>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'close'[],
        'close',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                closable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsChipStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onClose?: ((...args: any[]) => any) | undefined;
            }>,
        {
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            outline: boolean;
            primary: boolean;
            closable: boolean;
        },
        {},
        {
            XIcon: LucideIcon;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsContainer: DefineComponent<
        ExtractPropTypes<{
            tag: {
                type: StringConstructor;
                default: string;
            };
            layout: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>,
        {
            layoutStyles: ComputedRef<{}>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                layout: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>
        > &
            Readonly<{}>,
        {
            layout: boolean;
            tag: string;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsDatePicker: DefineComponent<
        ExtractPropTypes<{
            min: {
                type: StringConstructor;
                validator: (value: string, props: any) => boolean;
            };
            max: {
                type: StringConstructor;
                validator: (value: string, props: any) => boolean;
            };
            type: {
                type: PropType<VsDatePickerType>;
                default: string;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: PropType<VsDatePickerValueType>;
                default: string;
                validator: (value: string, props: any) => boolean;
            };
            styleSet: {
                type: PropType<string | VsDatePickerStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<string>[]>;
                default: () => Message<string>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<string>[]>;
                default: () => Rule<string>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>,
        {
            dateInputRef: Readonly<ShallowRef<VsInputRef | null>>;
            deceiveType: ComputedRef<VsInputType>;
            componentStyleSet: ComputedRef<Partial<VsDatePickerStyleSet>>;
            displayValue: ComputedRef<string>;
            computedPlaceholder: ComputedRef<string>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            computedState: ComputedRef<UIState>;
            computedIcon: ComputedRef<Component>;
            shake: Ref<boolean, boolean>;
            computedId: ComputedRef<string>;
            onDateInput: (value: string | number | null) => void;
            onPointerDown: () => void;
            onClick: () => void;
            onKeydownEnter: (e: KeyboardEvent) => void;
            onFocus: (e: FocusEvent) => void;
            onBlur: (e: FocusEvent) => void;
            focus: () => void;
            blur: () => void;
            clear: () => void;
            reset: () => void;
            validate: () => boolean;
            open: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('blur' | 'change' | 'focus' | 'invalid' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
        'blur' | 'change' | 'focus' | 'invalid' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                min: {
                    type: StringConstructor;
                    validator: (value: string, props: any) => boolean;
                };
                max: {
                    type: StringConstructor;
                    validator: (value: string, props: any) => boolean;
                };
                type: {
                    type: PropType<VsDatePickerType>;
                    default: string;
                };
                noClear: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                modelValue: {
                    type: PropType<VsDatePickerValueType>;
                    default: string;
                    validator: (value: string, props: any) => boolean;
                };
                styleSet: {
                    type: PropType<string | VsDatePickerStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<string>[]>;
                    default: () => Message<string>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                placeholder: {
                    type: typeof String;
                    default: string;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<string>[]>;
                    default: () => Rule<string>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
            }>
        > &
            Readonly<{
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                onInvalid?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            messages: Message<string>[];
            name: string;
            noDefaultRules: boolean;
            placeholder: string;
            readonly: boolean;
            rules: Rule<string>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            type: VsDatePickerType;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            modelValue: string;
            noClear: boolean;
        },
        {},
        {
            CalendarIcon: LucideIcon;
            ClockIcon: LucideIcon;
            VsInput: DefineComponent<
                ExtractPropTypes<{
                    autocomplete: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    noClear: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<VsInputType>;
                        default: string;
                    };
                    modelValue: {
                        type: PropType<VsInputValueType>;
                        default: null;
                    };
                    modelModifiers: {
                        type: PropType<StringModifiers>;
                        default: () => {};
                    };
                    min: {
                        type: PropType<number | string>;
                        default: string | number;
                        validator: (value: number | string) => boolean;
                    };
                    max: {
                        type: PropType<number | string>;
                        default: string | number;
                        validator: (value: number | string) => boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<VsInputValueType>[]>;
                        default: () => Message<VsInputValueType>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    placeholder: {
                        type: typeof String;
                        default: string;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<VsInputValueType>[]>;
                        default: () => Rule<VsInputValueType>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                }>,
                {
                    inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                    classObj: ComputedRef<{
                        [x: string]: boolean;
                        'vs-focus-visible': boolean;
                        'vs-focus-within': boolean;
                        'vs-disabled': boolean;
                        'vs-readonly': boolean;
                    }>;
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    inputValue: Ref<VsInputValueType, VsInputValueType>;
                    computedMessages: ComputedRef<StateMessage<UIState>[]>;
                    computedDisabled: ComputedRef<boolean>;
                    computedReadonly: ComputedRef<boolean>;
                    renderClearButton: ComputedRef<boolean>;
                    shake: Ref<boolean, boolean>;
                    stateBoxClasses: ComputedRef<{}>;
                    computedId: ComputedRef<string>;
                    onInput: (event: Event) => void;
                    focus: () => void;
                    blur: () => void;
                    select: () => void;
                    clear: () => void;
                    reset: () => void;
                    onFocus: (e: FocusEvent) => void;
                    onBlur: (e: FocusEvent) => void;
                    validate: () => boolean;
                    clearWithFocus: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
                'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        autocomplete: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        noClear: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<VsInputType>;
                            default: string;
                        };
                        modelValue: {
                            type: PropType<VsInputValueType>;
                            default: null;
                        };
                        modelModifiers: {
                            type: PropType<StringModifiers>;
                            default: () => {};
                        };
                        min: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        max: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        messages: {
                            type: PropType<Message<VsInputValueType>[]>;
                            default: () => Message<VsInputValueType>[];
                        };
                        name: {
                            type: typeof String;
                            default: string;
                        };
                        noDefaultRules: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        placeholder: {
                            type: typeof String;
                            default: string;
                        };
                        readonly: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        rules: {
                            type: PropType<Rule<VsInputValueType>[]>;
                            default: () => Rule<VsInputValueType>[];
                        };
                        state: {
                            type: PropType<UIState>;
                            default: UIState;
                        };
                        changed: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        valid: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                    }>
                > &
                    Readonly<{
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onChange?: ((...args: any[]) => any) | undefined;
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        onClear?: ((...args: any[]) => any) | undefined;
                        'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                        'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    label: string;
                    messages: Message<VsInputValueType>[];
                    name: string;
                    noDefaultRules: boolean;
                    placeholder: string;
                    readonly: boolean;
                    rules: Rule<VsInputValueType>[];
                    state: UIState;
                    changed: boolean;
                    valid: boolean;
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    min: string | number;
                    max: string | number;
                    type: VsInputType;
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    modelValue: VsInputValueType;
                    autocomplete: boolean;
                    noClear: boolean;
                    modelModifiers: StringModifiers;
                },
                {},
                {
                    VsInputWrapper: DefineComponent<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            needToShake: Ref<boolean, boolean>;
                            componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                groupLabel: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                messages: {
                                    type: PropType<StateMessage<UIState>[]>;
                                    default: () => never[];
                                };
                                shake: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputWrapperStyleSet>;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            label: string;
                            messages: StateMessage<UIState>[];
                            disabled: boolean;
                            hidden: boolean;
                            id: string;
                            noLabel: boolean;
                            noMessages: boolean;
                            required: boolean;
                            groupLabel: boolean;
                            shake: boolean;
                        },
                        {},
                        {
                            VsResponsive: DefineComponent<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>,
                                {
                                    responsiveClasses: ComputedRef<string[]>;
                                    responsiveStyles: ComputedRef<Record<string, string>>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        tag: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    tag: string;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsMessage: DefineComponent<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>,
                                {
                                    colorClass: ComputedRef<
                                        'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                    >;
                                    icon: ComputedRef<Component>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        state: {
                                            type: PropType<UIState>;
                                            default: string;
                                        };
                                        text: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsMessageStyleSet>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    text: string;
                                    state: UIState;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    XIcon: LucideIcon;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsDimmed: DefineComponent<
        ExtractPropTypes<{
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsDimmedStyleSet>;
            };
        }>,
        {
            isShow: Ref<boolean, boolean>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            show: () => void;
            hide: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'update:modelValue'[],
        'update:modelValue',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsDimmedStyleSet>;
                };
            }>
        > &
            Readonly<{
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            modelValue: boolean;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsDivider: DefineComponent<
        ExtractPropTypes<{
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsDividerStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                'vs-vertical': boolean;
                'vs-divider-responsive': boolean;
            }>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsDividerStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {
            vertical: boolean;
            responsive: boolean;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsDrawer: DefineComponent<
        ExtractPropTypes<{
            fixed: {
                type: BooleanConstructor;
                default: boolean;
            };
            open: {
                type: BooleanConstructor;
                default: boolean;
            };
            pushContainer: {
                type: BooleanConstructor;
                default: boolean;
            };
            placement: {
                type: PropType<DrawerPlacement>;
                default: string;
            };
            size: {
                type: PropType<SizeProp>;
            };
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            layout: {
                type: BooleanConstructor;
                default: boolean;
            };
            callbacks: {
                type: PropType<OverlayCallbacks>;
                default: () => {};
            };
            dimClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            dimmed: {
                type: BooleanConstructor;
                default: boolean;
            };
            escClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            focusLock: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsDrawerStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            drawerRef: Readonly<ShallowRef<HTMLElement | null>>;
            focusTrapRef: Readonly<ShallowRef<FocusableRef | null>>;
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsDrawerStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            isOpen: Ref<boolean, boolean>;
            ANIMATION_DURATION: number;
            onClickDimmed: () => void;
            isDimmed: ComputedRef<boolean>;
            openDrawer: () => void;
            closeDrawer: () => void;
            layoutStyles: ComputedRef<{
                [key: string]: string;
            }>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('close' | 'open' | 'update:modelValue' | 'click-dimmed')[],
        'close' | 'open' | 'update:modelValue' | 'click-dimmed',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                fixed: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                open: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                pushContainer: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                placement: {
                    type: PropType<DrawerPlacement>;
                    default: string;
                };
                size: {
                    type: PropType<SizeProp>;
                };
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                layout: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                callbacks: {
                    type: PropType<OverlayCallbacks>;
                    default: () => {};
                };
                dimClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                dimmed: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                escClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                focusLock: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                id: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsDrawerStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClose?: ((...args: any[]) => any) | undefined;
                onOpen?: ((...args: any[]) => any) | undefined;
                'onClick-dimmed'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            id: string;
            fixed: boolean;
            open: boolean;
            layout: boolean;
            modelValue: boolean;
            hideScroll: boolean;
            pushContainer: boolean;
            placement: DrawerPlacement;
            callbacks: OverlayCallbacks;
            dimmed: boolean;
            dimClose: boolean;
            escClose: boolean;
            focusLock: boolean;
        },
        {},
        {
            VsDimmed: DefineComponent<
                ExtractPropTypes<{
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsDimmedStyleSet>;
                    };
                }>,
                {
                    isShow: Ref<boolean, boolean>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    show: () => void;
                    hide: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                'update:modelValue'[],
                'update:modelValue',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        modelValue: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsDimmedStyleSet>;
                        };
                    }>
                > &
                    Readonly<{
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    modelValue: boolean;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsFocusTrap: DefineComponent<
                ExtractPropTypes<{
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>,
                () =>
                    | VNode<
                          RendererNode,
                          RendererElement,
                          {
                              [key: string]: any;
                          }
                      >
                    | VNode<
                          RendererNode,
                          RendererElement,
                          {
                              [key: string]: any;
                          }
                      >[]
                    | null,
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    disabled: boolean;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsInnerScroll: DefineComponent<
                ExtractPropTypes<{
                    hideScroll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInnerScrollStyleSet>;
                    };
                }>,
                {
                    componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    hasScroll: () => boolean;
                    bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        hideScroll: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInnerScrollStyleSet>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    hideScroll: boolean;
                },
                {},
                {},
                {
                    scrollShadow: Directive<HTMLElement, boolean | undefined>;
                },
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsExpandable: DefineComponent<
        ExtractPropTypes<{
            open: {
                type: BooleanConstructor;
                required: true;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsExpandableStyleSet>;
            };
        }>,
        {
            sizeClass: ComputedRef<string>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            beforeEnter: (el: Element) => void;
            enter: (el: Element, done: () => void) => void;
            beforeLeave: (el: Element) => void;
            leave: (el: Element, done: () => void) => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                open: {
                    type: BooleanConstructor;
                    required: true;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsExpandableStyleSet>;
                };
            }>
        > &
            Readonly<{}>,
        {
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsFileDrop: DefineComponent<
        ExtractPropTypes<{
            accept: {
                type: StringConstructor;
                default: string;
            };
            height: {
                type: PropType<string | number | Breakpoints>;
                default: string;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: PropType<FileDropValueType>;
                default: () => never[];
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            styleSet: {
                type: PropType<string | VsFileDropStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<FileDropValueType>[]>;
                default: () => Message<FileDropValueType>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<FileDropValueType>[]>;
                default: () => Rule<FileDropValueType>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>,
        {
            fileDropRef: Readonly<ShallowRef<HTMLInputElement | null>>;
            computedId: ComputedRef<string>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            shake: Ref<boolean, boolean>;
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsFileDropStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                'vs-focus-visible': boolean;
                'vs-focus-within': boolean;
                'vs-disabled': boolean;
                'vs-readonly': boolean;
                'vs-dragging': boolean;
            }>;
            stateBoxClasses: ComputedRef<{}>;
            dragging: Ref<boolean, boolean>;
            inputValue: Ref<FileDropValueType, FileDropValueType>;
            hasValue: ComputedRef<boolean>;
            stringUtil: {
                createID(size?: number): string;
                convertToString(value: any): string;
                toStringSize(value: number | string): string;
                toFileSizeFormat(bytes: number): string;
                hash(str: string): string;
                kebabCase: kebabCase;
            };
            setDragging: (value: boolean) => void;
            openFileDialog: () => void;
            handleFileDialog: (event: Event) => void;
            handleFileDrop: (event: DragEvent) => void;
            handleFileRemove: (target: File) => void;
            onFocus: (e: FocusEvent) => void;
            onBlur: (e: FocusEvent) => void;
            focus: () => void;
            blur: () => void;
            validate: () => boolean;
            clear: () => void;
            reset: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('blur' | 'change' | 'drop' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
        'blur' | 'change' | 'drop' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                accept: {
                    type: StringConstructor;
                    default: string;
                };
                height: {
                    type: PropType<string | number | Breakpoints>;
                    default: string;
                };
                noClear: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modelValue: {
                    type: PropType<FileDropValueType>;
                    default: () => never[];
                };
                min: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                max: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                styleSet: {
                    type: PropType<string | VsFileDropStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<FileDropValueType>[]>;
                    default: () => Message<FileDropValueType>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                placeholder: {
                    type: typeof String;
                    default: string;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<FileDropValueType>[]>;
                    default: () => Rule<FileDropValueType>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
            }>
        > &
            Readonly<{
                onDrop?: ((...args: any[]) => any) | undefined;
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            messages: Message<FileDropValueType>[];
            name: string;
            noDefaultRules: boolean;
            placeholder: string;
            readonly: boolean;
            rules: Rule<FileDropValueType>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            min: string | number;
            max: string | number;
            height: string | number | Breakpoints;
            multiple: boolean;
            modelValue: FileDropValueType;
            noClear: boolean;
            accept: string;
        },
        {},
        {
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsChip: DefineComponent<
                ExtractPropTypes<{
                    closable: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsChipStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsChipStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    classObj: ComputedRef<{
                        [x: string]: boolean;
                        'vs-outline': boolean;
                        'vs-primary': boolean;
                    }>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                'close'[],
                'close',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        closable: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsChipStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        onClose?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    outline: boolean;
                    primary: boolean;
                    closable: boolean;
                },
                {},
                {
                    XIcon: LucideIcon;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            PaperclipIcon: LucideIcon;
            XIcon: LucideIcon;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsFloating: DefineComponent<
        ExtractPropTypes<{
            followWidth: {
                type: BooleanConstructor;
                default: boolean;
            };
            overlayId: {
                type: StringConstructor;
                default: string;
            };
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            target: {
                type: StringConstructor;
                required: boolean;
                default: string;
            };
            align: {
                type: PropType<Alignment>;
                default: 'start' | 'center' | 'end';
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            enterDelay: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            leaveDelay: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            margin: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            noAnimation: {
                type: BooleanConstructor;
                default: boolean;
            };
            placement: {
                type: PropType<Placement>;
                default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
            };
        }>,
        {
            floatingRef: Readonly<ShallowRef<HTMLElement | null>>;
            computedPlacement: Ref<
                'top' | 'right' | 'bottom' | 'left' | 'middle' | null,
                'top' | 'right' | 'bottom' | 'left' | 'middle' | null
            >;
            isVisible: Ref<boolean, boolean>;
            isFloated: Ref<boolean, boolean>;
            animationClass: ComputedRef<string | null>;
            floatingStyle: ComputedRef<
                | {
                      animationDelay?: undefined;
                  }
                | {
                      animationDelay: string;
                  }
            >;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'update:modelValue'[],
        'update:modelValue',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                followWidth: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                overlayId: {
                    type: StringConstructor;
                    default: string;
                };
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                target: {
                    type: StringConstructor;
                    required: boolean;
                    default: string;
                };
                align: {
                    type: PropType<Alignment>;
                    default: 'start' | 'center' | 'end';
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                enterDelay: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                leaveDelay: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                margin: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                noAnimation: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                placement: {
                    type: PropType<Placement>;
                    default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                };
            }>
        > &
            Readonly<{
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            disabled: boolean;
            margin: string | number;
            modelValue: boolean;
            target: string;
            placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
            overlayId: string;
            followWidth: boolean;
            align: 'start' | 'center' | 'end';
            enterDelay: string | number;
            leaveDelay: string | number;
            noAnimation: boolean;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsFocusTrap: DefineComponent<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>,
        () =>
            | VNode<
                  RendererNode,
                  RendererElement,
                  {
                      [key: string]: any;
                  }
              >
            | VNode<
                  RendererNode,
                  RendererElement,
                  {
                      [key: string]: any;
                  }
              >[]
            | null,
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>
        > &
            Readonly<{}>,
        {
            disabled: boolean;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsFooter: DefineComponent<
        ExtractPropTypes<{
            height: {
                type: StringConstructor;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            layout: {
                type: BooleanConstructor;
                default: boolean;
            };
            position: {
                type: PropType<CssPosition>;
            };
            styleSet: {
                type: PropType<string | VsFooterStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsFooterStyleSet>>;
            classObj: ComputedRef<{
                'vs-primary': boolean;
            }>;
            isLayoutChild: ComputedRef<boolean>;
            position: Ref<CssPosition | undefined, CssPosition | undefined>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                height: {
                    type: StringConstructor;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                layout: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                position: {
                    type: PropType<CssPosition>;
                };
                styleSet: {
                    type: PropType<string | VsFooterStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {
            layout: boolean;
            tag: string;
            primary: boolean;
        },
        {},
        {
            VsBar: DefineComponent<
                ExtractPropTypes<{
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    position: {
                        type: PropType<CssPosition>;
                    };
                    styleSet: {
                        type: PropType<string | VsBarStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    classObj: ComputedRef<{
                        'vs-primary': boolean;
                    }>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        position: {
                            type: PropType<CssPosition>;
                        };
                        styleSet: {
                            type: PropType<string | VsBarStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                    primary: boolean;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsForm: DefineComponent<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            gridSize: {
                type: (StringConstructor | NumberConstructor)[];
            };
            columnGap: {
                type: (StringConstructor | NumberConstructor)[];
            };
            rowGap: {
                type: (StringConstructor | NumberConstructor)[];
            };
        }>,
        {
            valid: ComputedRef<boolean>;
            changed: ComputedRef<boolean>;
            validate: () => Promise<boolean>;
            clear: () => void;
            reset: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'error'[],
        'error',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                readonly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                gridSize: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                columnGap: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                rowGap: {
                    type: (StringConstructor | NumberConstructor)[];
                };
            }>
        > &
            Readonly<{
                onError?: ((...args: any[]) => any) | undefined;
            }>,
        {
            readonly: boolean;
            disabled: boolean;
        },
        {},
        {
            VsGrid: DefineComponent<
                ExtractPropTypes<{
                    width: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsGridStyleSet>;
                    };
                    gridSize: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    columnGap: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    rowGap: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                }>,
                {
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        width: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsGridStyleSet>;
                        };
                        gridSize: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        columnGap: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        rowGap: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsGrid: DefineComponent<
        ExtractPropTypes<{
            width: {
                type: (StringConstructor | NumberConstructor)[];
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsGridStyleSet>;
            };
            gridSize: {
                type: (StringConstructor | NumberConstructor)[];
            };
            columnGap: {
                type: (StringConstructor | NumberConstructor)[];
            };
            rowGap: {
                type: (StringConstructor | NumberConstructor)[];
            };
        }>,
        {
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                width: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsGridStyleSet>;
                };
                gridSize: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                columnGap: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                rowGap: {
                    type: (StringConstructor | NumberConstructor)[];
                };
            }>
        > &
            Readonly<{}>,
        {
            tag: string;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsHeader: DefineComponent<
        ExtractPropTypes<{
            height: {
                type: StringConstructor;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            layout: {
                type: BooleanConstructor;
                default: boolean;
            };
            position: {
                type: PropType<CssPosition>;
            };
            styleSet: {
                type: PropType<string | VsHeaderStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsHeaderStyleSet>>;
            classObj: ComputedRef<{
                'vs-primary': boolean;
            }>;
            isLayoutChild: ComputedRef<boolean>;
            position: Ref<CssPosition | undefined, CssPosition | undefined>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                height: {
                    type: StringConstructor;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                layout: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                position: {
                    type: PropType<CssPosition>;
                };
                styleSet: {
                    type: PropType<string | VsHeaderStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {
            layout: boolean;
            tag: string;
            primary: boolean;
        },
        {},
        {
            VsBar: DefineComponent<
                ExtractPropTypes<{
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    position: {
                        type: PropType<CssPosition>;
                    };
                    styleSet: {
                        type: PropType<string | VsBarStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    classObj: ComputedRef<{
                        'vs-primary': boolean;
                    }>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        position: {
                            type: PropType<CssPosition>;
                        };
                        styleSet: {
                            type: PropType<string | VsBarStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                    primary: boolean;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsImage: DefineComponent<
        ExtractPropTypes<{
            alt: {
                type: StringConstructor;
                default: string;
            };
            fallback: {
                type: StringConstructor;
                default: string;
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            lazy: {
                type: BooleanConstructor;
                default: boolean;
            };
            noSkeleton: {
                type: BooleanConstructor;
                default: boolean;
            };
            src: {
                type: StringConstructor;
                required: true;
                default: string;
            };
            width: {
                type: (StringConstructor | NumberConstructor)[];
            };
            styleSet: {
                type: PropType<string | VsImageStyleSet>;
            };
        }>,
        {
            componentStyleSet: ComputedRef<Partial<VsImageStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            computedSrc: ComputedRef<string>;
            vsImageRef: Ref<null, null>;
            isLoading: Ref<boolean, boolean>;
            isNoImage: Ref<boolean, boolean>;
            onImageLoad: () => void;
            onImageError: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'error'[],
        'error',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                alt: {
                    type: StringConstructor;
                    default: string;
                };
                fallback: {
                    type: StringConstructor;
                    default: string;
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                lazy: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                noSkeleton: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                src: {
                    type: StringConstructor;
                    required: true;
                    default: string;
                };
                width: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                styleSet: {
                    type: PropType<string | VsImageStyleSet>;
                };
            }>
        > &
            Readonly<{
                onError?: ((...args: any[]) => any) | undefined;
            }>,
        {
            alt: string;
            fallback: string;
            lazy: boolean;
            noSkeleton: boolean;
            src: string;
        },
        {},
        {
            VsSkeleton: DefineComponent<
                ExtractPropTypes<{
                    styleSet: {
                        type: PropType<string | VsSkeletonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsSkeletonStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        styleSet: {
                            type: PropType<string | VsSkeletonStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {},
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            ImageOffIcon: LucideIcon;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsIndexView: DefineComponent<
        ExtractPropTypes<{
            keepAlive: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: NumberConstructor;
                default: number;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>,
        () => VNode<
            RendererNode,
            RendererElement,
            {
                [key: string]: any;
            }
        > | null,
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'update:modelValue'[],
        'update:modelValue',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                keepAlive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modelValue: {
                    type: NumberConstructor;
                    default: number;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>
        > &
            Readonly<{
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            modelValue: number;
            keepAlive: boolean;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsInnerScroll: DefineComponent<
        ExtractPropTypes<{
            hideScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsInnerScrollStyleSet>;
            };
        }>,
        {
            componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            hasScroll: () => boolean;
            bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                hideScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInnerScrollStyleSet>;
                };
            }>
        > &
            Readonly<{}>,
        {
            hideScroll: boolean;
        },
        {},
        {},
        {
            scrollShadow: Directive<HTMLElement, boolean | undefined>;
        },
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsInput: DefineComponent<
        ExtractPropTypes<{
            autocomplete: {
                type: BooleanConstructor;
                default: boolean;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            type: {
                type: PropType<VsInputType>;
                default: string;
            };
            modelValue: {
                type: PropType<VsInputValueType>;
                default: null;
            };
            modelModifiers: {
                type: PropType<StringModifiers>;
                default: () => {};
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            styleSet: {
                type: PropType<string | VsInputStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<VsInputValueType>[]>;
                default: () => Message<VsInputValueType>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<VsInputValueType>[]>;
                default: () => Rule<VsInputValueType>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>,
        {
            inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
            classObj: ComputedRef<{
                [x: string]: boolean;
                'vs-focus-visible': boolean;
                'vs-focus-within': boolean;
                'vs-disabled': boolean;
                'vs-readonly': boolean;
            }>;
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            inputValue: Ref<VsInputValueType, VsInputValueType>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            renderClearButton: ComputedRef<boolean>;
            shake: Ref<boolean, boolean>;
            stateBoxClasses: ComputedRef<{}>;
            computedId: ComputedRef<string>;
            onInput: (event: Event) => void;
            focus: () => void;
            blur: () => void;
            select: () => void;
            clear: () => void;
            reset: () => void;
            onFocus: (e: FocusEvent) => void;
            onBlur: (e: FocusEvent) => void;
            validate: () => boolean;
            clearWithFocus: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
        'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                autocomplete: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                noClear: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<VsInputType>;
                    default: string;
                };
                modelValue: {
                    type: PropType<VsInputValueType>;
                    default: null;
                };
                modelModifiers: {
                    type: PropType<StringModifiers>;
                    default: () => {};
                };
                min: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                max: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<VsInputValueType>[]>;
                    default: () => Message<VsInputValueType>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                placeholder: {
                    type: typeof String;
                    default: string;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<VsInputValueType>[]>;
                    default: () => Rule<VsInputValueType>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
            }>
        > &
            Readonly<{
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            messages: Message<VsInputValueType>[];
            name: string;
            noDefaultRules: boolean;
            placeholder: string;
            readonly: boolean;
            rules: Rule<VsInputValueType>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            min: string | number;
            max: string | number;
            type: VsInputType;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            modelValue: VsInputValueType;
            autocomplete: boolean;
            noClear: boolean;
            modelModifiers: StringModifiers;
        },
        {},
        {
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            XIcon: LucideIcon;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsInputWrapper: DefineComponent<
        ExtractPropTypes<{
            groupLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            messages: {
                type: PropType<StateMessage<UIState>[]>;
                default: () => never[];
            };
            shake: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsInputWrapperStyleSet>;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            label: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>,
        {
            needToShake: Ref<boolean, boolean>;
            componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>
        > &
            Readonly<{}>,
        {
            label: string;
            messages: StateMessage<UIState>[];
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            groupLabel: boolean;
            shake: boolean;
        },
        {},
        {
            VsResponsive: DefineComponent<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    responsiveClasses: ComputedRef<string[]>;
                    responsiveStyles: ComputedRef<Record<string, string>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsMessage: DefineComponent<
                ExtractPropTypes<{
                    state: {
                        type: PropType<UIState>;
                        default: string;
                    };
                    text: {
                        type: StringConstructor;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsMessageStyleSet>;
                    };
                }>,
                {
                    colorClass: ComputedRef<
                        'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                    >;
                    icon: ComputedRef<Component>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    text: string;
                    state: UIState;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsLabelValue: DefineComponent<
        ExtractPropTypes<{
            size: {
                type: PropType<Size>;
                default: string;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            styleSet: {
                type: PropType<string | VsLabelValueStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            classObj: ComputedRef<{
                [x: string]: boolean;
                'vs-primary': boolean;
                'vs-vertical': boolean;
                'vs-responsive-vertical': boolean;
            }>;
            colorSchemeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentStyleSet: ComputedRef<Partial<VsLabelValueStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                styleSet: {
                    type: PropType<string | VsLabelValueStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            vertical: boolean;
            primary: boolean;
            responsive: boolean;
        },
        {},
        {
            VsResponsive: DefineComponent<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    responsiveClasses: ComputedRef<string[]>;
                    responsiveStyles: ComputedRef<Record<string, string>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsLayout: DefineComponent<
        {},
        {},
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<{}> & Readonly<{}>,
        {},
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsLoading: DefineComponent<
        ExtractPropTypes<{
            width: {
                type: (StringConstructor | NumberConstructor)[];
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            styleSet: {
                type: PropType<string | VsLoadingStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                width: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                styleSet: {
                    type: PropType<string | VsLoadingStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {},
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsMessage: DefineComponent<
        ExtractPropTypes<{
            state: {
                type: PropType<UIState>;
                default: string;
            };
            text: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsMessageStyleSet>;
            };
        }>,
        {
            colorClass: ComputedRef<'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'>;
            icon: ComputedRef<Component>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                state: {
                    type: PropType<UIState>;
                    default: string;
                };
                text: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsMessageStyleSet>;
                };
            }>
        > &
            Readonly<{}>,
        {
            text: string;
            state: UIState;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsModal: DefineComponent<
        ExtractPropTypes<{
            beforeClose: {
                type: PropType<() => Promise<boolean> | boolean>;
                default: undefined;
            };
            container: {
                type: StringConstructor;
                default: string;
            };
            escClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollLock: {
                type: PropType<boolean | string>;
                default: boolean;
            };
            size: {
                type: PropType<
                    | SizeProp
                    | {
                          width?: SizeProp;
                          height?: SizeProp;
                      }
                >;
            };
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            callbacks: {
                type: PropType<OverlayCallbacks>;
                default: () => {};
            };
            dimClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            dimmed: {
                type: BooleanConstructor;
                default: boolean;
            };
            focusLock: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsModalNodeStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        () => null,
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('close' | 'open' | 'update:modelValue')[],
        'close' | 'open' | 'update:modelValue',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                beforeClose: {
                    type: PropType<() => Promise<boolean> | boolean>;
                    default: undefined;
                };
                container: {
                    type: StringConstructor;
                    default: string;
                };
                escClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                scrollLock: {
                    type: PropType<boolean | string>;
                    default: boolean;
                };
                size: {
                    type: PropType<
                        | SizeProp
                        | {
                              width?: SizeProp;
                              height?: SizeProp;
                          }
                    >;
                };
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                callbacks: {
                    type: PropType<OverlayCallbacks>;
                    default: () => {};
                };
                dimClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                dimmed: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                focusLock: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                id: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsModalNodeStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClose?: ((...args: any[]) => any) | undefined;
                onOpen?: ((...args: any[]) => any) | undefined;
            }>,
        {
            id: string;
            container: string;
            modelValue: boolean;
            hideScroll: boolean;
            callbacks: OverlayCallbacks;
            dimmed: boolean;
            dimClose: boolean;
            escClose: boolean;
            focusLock: boolean;
            beforeClose: () => Promise<boolean> | boolean;
            scrollLock: string | boolean;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsModalNode: DefineComponent<
        ExtractPropTypes<{
            beforeClose: {
                type: PropType<() => Promise<boolean> | boolean>;
                default: undefined;
            };
            container: {
                type: StringConstructor;
                default: string;
            };
            escClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            dimClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollLock: {
                type: PropType<boolean | string>;
                default: boolean;
            };
            size: {
                type: PropType<
                    | SizeProp
                    | {
                          width?: SizeProp;
                          height?: SizeProp;
                      }
                >;
            };
            callbacks: {
                type: PropType<OverlayCallbacks>;
                default: () => {};
            };
            dimmed: {
                type: BooleanConstructor;
                default: boolean;
            };
            focusLock: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsModalNodeStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsModalNodeStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            focusLock: Ref<boolean, boolean>;
            onClickDimmed: () => Promise<void>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('close' | 'click-dimmed')[],
        'close' | 'click-dimmed',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                beforeClose: {
                    type: PropType<() => Promise<boolean> | boolean>;
                    default: undefined;
                };
                container: {
                    type: StringConstructor;
                    default: string;
                };
                escClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                dimClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                scrollLock: {
                    type: PropType<boolean | string>;
                    default: boolean;
                };
                size: {
                    type: PropType<
                        | SizeProp
                        | {
                              width?: SizeProp;
                              height?: SizeProp;
                          }
                    >;
                };
                callbacks: {
                    type: PropType<OverlayCallbacks>;
                    default: () => {};
                };
                dimmed: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                focusLock: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                id: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsModalNodeStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onClose?: ((...args: any[]) => any) | undefined;
                'onClick-dimmed'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            id: string;
            container: string;
            hideScroll: boolean;
            callbacks: OverlayCallbacks;
            dimmed: boolean;
            dimClose: boolean;
            escClose: boolean;
            focusLock: boolean;
            beforeClose: () => Promise<boolean> | boolean;
            scrollLock: string | boolean;
        },
        {},
        {
            VsDimmed: DefineComponent<
                ExtractPropTypes<{
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsDimmedStyleSet>;
                    };
                }>,
                {
                    isShow: Ref<boolean, boolean>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    show: () => void;
                    hide: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                'update:modelValue'[],
                'update:modelValue',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        modelValue: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsDimmedStyleSet>;
                        };
                    }>
                > &
                    Readonly<{
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    modelValue: boolean;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsFocusTrap: DefineComponent<
                ExtractPropTypes<{
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>,
                () =>
                    | VNode<
                          RendererNode,
                          RendererElement,
                          {
                              [key: string]: any;
                          }
                      >
                    | VNode<
                          RendererNode,
                          RendererElement,
                          {
                              [key: string]: any;
                          }
                      >[]
                    | null,
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    disabled: boolean;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsModalView: DefineComponent<
        ExtractPropTypes<{
            container: {
                type: StringConstructor;
                default: string;
            };
        }>,
        {
            modals: ComputedRef<ModalInfo[]>;
            isFixed: ComputedRef<boolean>;
            ANIMATION_DURATION: number;
            onClose: (id: string) => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                container: {
                    type: StringConstructor;
                    default: string;
                };
            }>
        > &
            Readonly<{}>,
        {
            container: string;
        },
        {},
        {
            VsModalNode: DefineComponent<
                ExtractPropTypes<{
                    beforeClose: {
                        type: PropType<() => Promise<boolean> | boolean>;
                        default: undefined;
                    };
                    container: {
                        type: StringConstructor;
                        default: string;
                    };
                    escClose: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    dimClose: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    scrollLock: {
                        type: PropType<boolean | string>;
                        default: boolean;
                    };
                    size: {
                        type: PropType<
                            | SizeProp
                            | {
                                  width?: SizeProp;
                                  height?: SizeProp;
                              }
                        >;
                    };
                    callbacks: {
                        type: PropType<OverlayCallbacks>;
                        default: () => {};
                    };
                    dimmed: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    focusLock: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideScroll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    id: {
                        type: StringConstructor;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsModalNodeStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsModalNodeStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    focusLock: Ref<boolean, boolean>;
                    onClickDimmed: () => Promise<void>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('close' | 'click-dimmed')[],
                'close' | 'click-dimmed',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        beforeClose: {
                            type: PropType<() => Promise<boolean> | boolean>;
                            default: undefined;
                        };
                        container: {
                            type: StringConstructor;
                            default: string;
                        };
                        escClose: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        dimClose: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        scrollLock: {
                            type: PropType<boolean | string>;
                            default: boolean;
                        };
                        size: {
                            type: PropType<
                                | SizeProp
                                | {
                                      width?: SizeProp;
                                      height?: SizeProp;
                                  }
                            >;
                        };
                        callbacks: {
                            type: PropType<OverlayCallbacks>;
                            default: () => {};
                        };
                        dimmed: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        focusLock: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        hideScroll: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        id: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsModalNodeStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        onClose?: ((...args: any[]) => any) | undefined;
                        'onClick-dimmed'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    id: string;
                    container: string;
                    hideScroll: boolean;
                    callbacks: OverlayCallbacks;
                    dimmed: boolean;
                    dimClose: boolean;
                    escClose: boolean;
                    focusLock: boolean;
                    beforeClose: () => Promise<boolean> | boolean;
                    scrollLock: string | boolean;
                },
                {},
                {
                    VsDimmed: DefineComponent<
                        ExtractPropTypes<{
                            modelValue: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsDimmedStyleSet>;
                            };
                        }>,
                        {
                            isShow: Ref<boolean, boolean>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                            show: () => void;
                            hide: () => void;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        'update:modelValue'[],
                        'update:modelValue',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                modelValue: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsDimmedStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{
                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            modelValue: boolean;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsFocusTrap: DefineComponent<
                        ExtractPropTypes<{
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                        }>,
                        () =>
                            | VNode<
                                  RendererNode,
                                  RendererElement,
                                  {
                                      [key: string]: any;
                                  }
                              >
                            | VNode<
                                  RendererNode,
                                  RendererElement,
                                  {
                                      [key: string]: any;
                                  }
                              >[]
                            | null,
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            disabled: boolean;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsRender: DefineComponent<
                ExtractPropTypes<{
                    content: {
                        type: PropType<string | Component>;
                        required: true;
                    };
                    componentProps: {
                        type: PropType<Record<string, any>>;
                        default: () => {};
                    };
                }>,
                () => VNode<
                    RendererNode,
                    RendererElement,
                    {
                        [key: string]: any;
                    }
                >,
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        content: {
                            type: PropType<string | Component>;
                            required: true;
                        };
                        componentProps: {
                            type: PropType<Record<string, any>>;
                            default: () => {};
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    componentProps: Record<string, any>;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsGroupedList: DefineComponent<
        ExtractPropTypes<{
            items: {
                type: PropType<OptionItem[]>;
                default: () => never[];
            };
            groupBy: {
                type: PropType<(option: any, index: number) => string | null> | null;
                default: null;
            };
            groupOrder: {
                type: PropType<string[]>;
                default: () => never[];
            };
            styleSet: {
                type: PropType<string | VsGroupedListStyleSet>;
            };
        }>,
        {
            visibleRenderRef: Readonly<ShallowRef<VsVisibleRenderRef | null>>;
            innerScrollRef: Readonly<ShallowRef<VsInnerScrollRef | null>>;
            componentStyleSet: ComputedRef<Partial<VsGroupedListStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            groupedItems: ComputedRef<VsGroupedListGroup[]>;
            emitClickItem: (
                item: OptionItem,
                groupedIndex: number,
                group: VsGroupedListGroup,
                groupIndex: number,
            ) => void;
            scrollToItem: (id: string) => void;
            hasScroll: () => boolean;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'click-item'[],
        'click-item',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                items: {
                    type: PropType<OptionItem[]>;
                    default: () => never[];
                };
                groupBy: {
                    type: PropType<(option: any, index: number) => string | null> | null;
                    default: null;
                };
                groupOrder: {
                    type: PropType<string[]>;
                    default: () => never[];
                };
                styleSet: {
                    type: PropType<string | VsGroupedListStyleSet>;
                };
            }>
        > &
            Readonly<{
                'onClick-item'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            items: OptionItem[];
            groupBy: (option: any, index: number) => string | null;
            groupOrder: string[];
        },
        {},
        {
            VsInnerScroll: DefineComponent<
                ExtractPropTypes<{
                    hideScroll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInnerScrollStyleSet>;
                    };
                }>,
                {
                    componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    hasScroll: () => boolean;
                    bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        hideScroll: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInnerScrollStyleSet>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    hideScroll: boolean;
                },
                {},
                {},
                {
                    scrollShadow: Directive<HTMLElement, boolean | undefined>;
                },
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsVisibleRender: DefineComponent<
                ExtractPropTypes<{
                    selector: {
                        type: StringConstructor;
                        default: null;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    rootMargin: {
                        type: StringConstructor;
                        default: string;
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    threshold: {
                        type: NumberConstructor;
                        default: number;
                        validator: (value: number) => boolean;
                    };
                }>,
                {
                    containerStyle: ComputedRef<
                        | {
                              height?: undefined;
                              overflowY?: undefined;
                          }
                        | {
                              height: string;
                              overflowY: string;
                          }
                    >;
                    scrollToElement: (element: HTMLElement) => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        selector: {
                            type: StringConstructor;
                            default: null;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        rootMargin: {
                            type: StringConstructor;
                            default: string;
                        };
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        threshold: {
                            type: NumberConstructor;
                            default: number;
                            validator: (value: number) => boolean;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    disabled: boolean;
                    tag: string;
                    selector: string;
                    rootMargin: string;
                    threshold: number;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsPage: DefineComponent<
        ExtractPropTypes<{
            styleSet: {
                type: PropType<string | VsPageStyleSet>;
            };
        }>,
        {
            componentStyleSet: ComputedRef<Partial<VsPageStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                styleSet: {
                    type: PropType<string | VsPageStyleSet>;
                };
            }>
        > &
            Readonly<{}>,
        {},
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsPagination: DefineComponent<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            edgeButtons: {
                type: BooleanConstructor;
                default: boolean;
            };
            ghost: {
                type: BooleanConstructor;
                default: boolean;
            };
            length: {
                type: NumberConstructor;
                required: true;
                default: number;
                validator: (value: number) => boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            showingLength: {
                type: NumberConstructor;
                default: number;
                validator: (value: number) => boolean;
            };
            modelValue: {
                type: NumberConstructor;
                default: number;
            };
            styleSet: {
                type: PropType<string | VsPaginationStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            computedColorScheme: ComputedRef<
                | 'brown'
                | 'red'
                | 'orange'
                | 'amber'
                | 'yellow'
                | 'lime'
                | 'green'
                | 'emerald'
                | 'teal'
                | 'cyan'
                | 'sky'
                | 'blue'
                | 'indigo'
                | 'violet'
                | 'purple'
                | 'fuchsia'
                | 'pink'
                | 'rose'
                | 'gray'
                | 'none'
                | undefined
            >;
            colorSchemeClass: ComputedRef<string>;
            sizeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsPaginationStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            selectedIndex: Ref<number, number>;
            pages: ComputedRef<number[]>;
            getPageButtonStyleSet: (page: number) => Omit<VsButtonStyleSet, '$loading'>;
            goFirst: () => void;
            goLast: () => void;
            goPrev: () => void;
            goNext: () => void;
            setPage: (page: number) => void;
            selectIndex: (index: number) => void;
            isFirstEdge: ComputedRef<boolean>;
            isLastEdge: ComputedRef<boolean>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('change' | 'update:modelValue')[],
        'change' | 'update:modelValue',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                edgeButtons: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                length: {
                    type: NumberConstructor;
                    required: true;
                    default: number;
                    validator: (value: number) => boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                showingLength: {
                    type: NumberConstructor;
                    default: number;
                    validator: (value: number) => boolean;
                };
                modelValue: {
                    type: NumberConstructor;
                    default: number;
                };
                styleSet: {
                    type: PropType<string | VsPaginationStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            disabled: boolean;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            length: number;
            outline: boolean;
            modelValue: number;
            ghost: boolean;
            edgeButtons: boolean;
            showingLength: number;
        },
        {},
        {
            VsButton: DefineComponent<
                ExtractPropTypes<{
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsButtonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    classObj: ComputedRef<{
                        [x: string]: boolean;
                        'vs-focus-visible': boolean;
                        'vs-circle': boolean;
                        'vs-disabled': boolean;
                        'vs-ghost': boolean;
                        'vs-loading-state': boolean;
                        'vs-outline': boolean;
                        'vs-primary': boolean;
                        'vs-responsive': boolean;
                    }>;
                    buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                    componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsButtonStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    circle: boolean;
                    disabled: boolean;
                    type: 'button' | 'reset' | 'submit';
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    outline: boolean;
                    primary: boolean;
                    ghost: boolean;
                    loading: boolean;
                    responsive: boolean;
                },
                {},
                {
                    VsLoading: DefineComponent<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                width: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                height: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                styleSet: {
                                    type: PropType<string | VsLoadingStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {},
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            ChevronFirstIcon: LucideIcon;
            ChevronLastIcon: LucideIcon;
            ChevronLeftIcon: LucideIcon;
            ChevronRightIcon: LucideIcon;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsProgress: DefineComponent<
        ExtractPropTypes<{
            max: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
                validator: (value: number | string) => boolean;
            };
            value: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
                validator: (value: number | string) => boolean;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsProgressStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            computedValue: ComputedRef<number>;
            computedMax: ComputedRef<number>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                max: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                    validator: (value: number | string) => boolean;
                };
                value: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                    validator: (value: number | string) => boolean;
                };
                label: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsProgressStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {
            label: string;
            max: string | number;
            value: string | number;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsRadio: DefineComponent<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                default: null;
            };
            checked: {
                type: BooleanConstructor;
                default: boolean;
            };
            radioLabel: {
                type: StringConstructor;
                default: string;
            };
            radioValue: {
                type: null;
                required: true;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: null;
                default: null;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsRadioStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            computedId: ComputedRef<string>;
            radioRef: Readonly<ShallowRef<HTMLInputElement | null>>;
            isChecked: ComputedRef<boolean>;
            colorSchemeClass: ComputedRef<string>;
            computedState: ComputedRef<UIState>;
            componentStyleSet: ComputedRef<Partial<VsRadioStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            classObj: ComputedRef<{
                'vs-disabled': boolean;
                'vs-focus-visible': boolean;
                'vs-readonly': boolean;
            }>;
            sizeClass: ComputedRef<string>;
            stateBoxClasses: ComputedRef<{}>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            inputValue: Ref<any, any>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            shake: Ref<boolean, boolean>;
            validate: () => boolean;
            clear: () => void;
            reset: () => void;
            onToggle: (event: Event) => Promise<void>;
            onFocus: (e: FocusEvent) => void;
            onBlur: (e: FocusEvent) => void;
            focus: () => void;
            blur: () => void;
            convertToString: (value: any) => string;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
        'blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                beforeChange: {
                    type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                    default: null;
                };
                checked: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                radioLabel: {
                    type: StringConstructor;
                    default: string;
                };
                radioValue: {
                    type: null;
                    required: true;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                modelValue: {
                    type: null;
                    default: null;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<any>[]>;
                    default: () => Message<any>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<any>[]>;
                    default: () => Rule<any>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsRadioStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                onToggle?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            messages: Message<any>[];
            name: string;
            noDefaultRules: boolean;
            readonly: boolean;
            rules: Rule<any>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            modelValue: any;
            beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
            checked: boolean;
            radioLabel: string;
        },
        {},
        {
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsRadioSet: DefineComponent<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                default: null;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: null;
                default: null;
            };
            options: {
                type: PropType<any[]>;
                default: () => never[];
            };
            optionLabel: {
                type: StringConstructor;
                default: string;
            };
            optionValue: {
                type: StringConstructor;
                default: string;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsRadioSetStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            hidden: Ref<boolean, boolean>;
            label: Ref<string, string>;
            width: Ref<string | number | Breakpoints | undefined, string | number | Breakpoints | undefined>;
            grid: Ref<string | number | Breakpoints | undefined, string | number | Breakpoints | undefined>;
            noMessages: Ref<boolean, boolean>;
            colorScheme: Ref<
                | 'brown'
                | 'red'
                | 'orange'
                | 'amber'
                | 'yellow'
                | 'lime'
                | 'green'
                | 'emerald'
                | 'teal'
                | 'cyan'
                | 'sky'
                | 'blue'
                | 'indigo'
                | 'violet'
                | 'purple'
                | 'fuchsia'
                | 'pink'
                | 'rose'
                | 'gray'
                | 'none'
                | undefined,
                | 'brown'
                | 'red'
                | 'orange'
                | 'amber'
                | 'yellow'
                | 'lime'
                | 'green'
                | 'emerald'
                | 'teal'
                | 'cyan'
                | 'sky'
                | 'blue'
                | 'indigo'
                | 'violet'
                | 'purple'
                | 'fuchsia'
                | 'pink'
                | 'rose'
                | 'gray'
                | 'none'
                | undefined
            >;
            options: Ref<any[], any[]>;
            required: Ref<boolean, boolean>;
            radioRefs: Readonly<
                ShallowRef<
                    | CreateComponentPublicInstanceWithMixins<
                          Readonly<
                              ExtractPropTypes<{
                                  beforeChange: {
                                      type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                      default: null;
                                  };
                                  checked: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  radioLabel: {
                                      type: StringConstructor;
                                      default: string;
                                  };
                                  radioValue: {
                                      type: null;
                                      required: true;
                                  };
                                  size: {
                                      type: PropType<Size>;
                                      default: string;
                                  };
                                  modelValue: {
                                      type: null;
                                      default: null;
                                  };
                                  width: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  grid: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  label: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  messages: {
                                      type: PropType<Message<any>[]>;
                                      default: () => Message<any>[];
                                  };
                                  name: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noDefaultRules: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  readonly: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  rules: {
                                      type: PropType<Rule<any>[]>;
                                      default: () => Rule<any>[];
                                  };
                                  state: {
                                      type: PropType<UIState>;
                                      default: UIState;
                                  };
                                  changed: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  valid: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  disabled: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  hidden: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  id: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noLabel: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  noMessages: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  required: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  styleSet: {
                                      type: PropType<string | VsRadioStyleSet>;
                                  };
                                  colorScheme: {
                                      type: PropType<ColorScheme>;
                                  };
                              }>
                          > &
                              Readonly<{
                                  onFocus?: ((...args: any[]) => any) | undefined;
                                  onBlur?: ((...args: any[]) => any) | undefined;
                                  onChange?: ((...args: any[]) => any) | undefined;
                                  onToggle?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                  onClear?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                              }>,
                          {
                              computedId: ComputedRef<string>;
                              radioRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                              isChecked: ComputedRef<boolean>;
                              colorSchemeClass: ComputedRef<string>;
                              computedState: ComputedRef<UIState>;
                              componentStyleSet: ComputedRef<Partial<VsRadioStyleSet>>;
                              styleSetVariables: ComputedRef<Record<string, string>>;
                              classObj: ComputedRef<{
                                  'vs-disabled': boolean;
                                  'vs-focus-visible': boolean;
                                  'vs-readonly': boolean;
                              }>;
                              sizeClass: ComputedRef<string>;
                              stateBoxClasses: ComputedRef<{}>;
                              computedDisabled: ComputedRef<boolean>;
                              computedReadonly: ComputedRef<boolean>;
                              inputValue: Ref<any, any>;
                              computedMessages: ComputedRef<StateMessage<UIState>[]>;
                              shake: Ref<boolean, boolean>;
                              validate: () => boolean;
                              clear: () => void;
                              reset: () => void;
                              onToggle: (event: Event) => Promise<void>;
                              onFocus: (e: FocusEvent) => void;
                              onBlur: (e: FocusEvent) => void;
                              focus: () => void;
                              blur: () => void;
                              convertToString: (value: any) => string;
                          },
                          {},
                          {},
                          {},
                          ComponentOptionsMixin,
                          ComponentOptionsMixin,
                          (
                              | 'blur'
                              | 'change'
                              | 'focus'
                              | 'toggle'
                              | 'clear'
                              | 'update:modelValue'
                              | 'update:changed'
                              | 'update:valid'
                          )[],
                          PublicProps,
                          {
                              label: string;
                              messages: Message<any>[];
                              name: string;
                              noDefaultRules: boolean;
                              readonly: boolean;
                              rules: Rule<any>[];
                              state: UIState;
                              changed: boolean;
                              valid: boolean;
                              disabled: boolean;
                              hidden: boolean;
                              id: string;
                              noLabel: boolean;
                              noMessages: boolean;
                              required: boolean;
                              size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                              modelValue: any;
                              beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                              checked: boolean;
                              radioLabel: string;
                          },
                          true,
                          {},
                          {},
                          {
                              VsInputWrapper: DefineComponent<
                                  ExtractPropTypes<{
                                      groupLabel: {
                                          type: BooleanConstructor;
                                          default: boolean;
                                      };
                                      messages: {
                                          type: PropType<StateMessage<UIState>[]>;
                                          default: () => never[];
                                      };
                                      shake: {
                                          type: BooleanConstructor;
                                          default: boolean;
                                      };
                                      styleSet: {
                                          type: PropType<string | VsInputWrapperStyleSet>;
                                      };
                                      disabled: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      hidden: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      id: {
                                          type: typeof String;
                                          default: string;
                                      };
                                      label: {
                                          type: typeof String;
                                          default: string;
                                      };
                                      noLabel: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      noMessages: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      required: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      width: {
                                          type: PropType<string | number | Breakpoints>;
                                      };
                                      grid: {
                                          type: PropType<string | number | Breakpoints>;
                                      };
                                  }>,
                                  {
                                      needToShake: Ref<boolean, boolean>;
                                      componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                      componentInlineStyle: ComputedRef<CSSProperties>;
                                  },
                                  {},
                                  {},
                                  {},
                                  ComponentOptionsMixin,
                                  ComponentOptionsMixin,
                                  {},
                                  string,
                                  PublicProps,
                                  Readonly<
                                      ExtractPropTypes<{
                                          groupLabel: {
                                              type: BooleanConstructor;
                                              default: boolean;
                                          };
                                          messages: {
                                              type: PropType<StateMessage<UIState>[]>;
                                              default: () => never[];
                                          };
                                          shake: {
                                              type: BooleanConstructor;
                                              default: boolean;
                                          };
                                          styleSet: {
                                              type: PropType<string | VsInputWrapperStyleSet>;
                                          };
                                          disabled: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          hidden: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          id: {
                                              type: typeof String;
                                              default: string;
                                          };
                                          label: {
                                              type: typeof String;
                                              default: string;
                                          };
                                          noLabel: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          noMessages: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          required: {
                                              type: typeof Boolean;
                                              default: boolean;
                                          };
                                          width: {
                                              type: PropType<string | number | Breakpoints>;
                                          };
                                          grid: {
                                              type: PropType<string | number | Breakpoints>;
                                          };
                                      }>
                                  > &
                                      Readonly<{}>,
                                  {
                                      label: string;
                                      messages: StateMessage<UIState>[];
                                      disabled: boolean;
                                      hidden: boolean;
                                      id: string;
                                      noLabel: boolean;
                                      noMessages: boolean;
                                      required: boolean;
                                      groupLabel: boolean;
                                      shake: boolean;
                                  },
                                  {},
                                  {
                                      VsResponsive: DefineComponent<
                                          ExtractPropTypes<{
                                              tag: {
                                                  type: StringConstructor;
                                                  default: string;
                                              };
                                              width: {
                                                  type: PropType<string | number | Breakpoints>;
                                              };
                                              grid: {
                                                  type: PropType<string | number | Breakpoints>;
                                              };
                                          }>,
                                          {
                                              responsiveClasses: ComputedRef<string[]>;
                                              responsiveStyles: ComputedRef<Record<string, string>>;
                                          },
                                          {},
                                          {},
                                          {},
                                          ComponentOptionsMixin,
                                          ComponentOptionsMixin,
                                          {},
                                          string,
                                          PublicProps,
                                          Readonly<
                                              ExtractPropTypes<{
                                                  tag: {
                                                      type: StringConstructor;
                                                      default: string;
                                                  };
                                                  width: {
                                                      type: PropType<string | number | Breakpoints>;
                                                  };
                                                  grid: {
                                                      type: PropType<string | number | Breakpoints>;
                                                  };
                                              }>
                                          > &
                                              Readonly<{}>,
                                          {
                                              tag: string;
                                          },
                                          {},
                                          {},
                                          {},
                                          string,
                                          ComponentProvideOptions,
                                          true,
                                          {},
                                          any
                                      >;
                                      VsMessage: DefineComponent<
                                          ExtractPropTypes<{
                                              state: {
                                                  type: PropType<UIState>;
                                                  default: string;
                                              };
                                              text: {
                                                  type: StringConstructor;
                                                  default: string;
                                              };
                                              styleSet: {
                                                  type: PropType<string | VsMessageStyleSet>;
                                              };
                                          }>,
                                          {
                                              colorClass: ComputedRef<
                                                  | 'vs-cs-blue'
                                                  | 'vs-cs-green'
                                                  | 'vs-cs-amber'
                                                  | 'vs-cs-red'
                                                  | 'vs-cs-default'
                                              >;
                                              icon: ComputedRef<Component>;
                                              styleSetVariables: ComputedRef<Record<string, string>>;
                                              componentInlineStyle: ComputedRef<CSSProperties>;
                                          },
                                          {},
                                          {},
                                          {},
                                          ComponentOptionsMixin,
                                          ComponentOptionsMixin,
                                          {},
                                          string,
                                          PublicProps,
                                          Readonly<
                                              ExtractPropTypes<{
                                                  state: {
                                                      type: PropType<UIState>;
                                                      default: string;
                                                  };
                                                  text: {
                                                      type: StringConstructor;
                                                      default: string;
                                                  };
                                                  styleSet: {
                                                      type: PropType<string | VsMessageStyleSet>;
                                                  };
                                              }>
                                          > &
                                              Readonly<{}>,
                                          {
                                              text: string;
                                              state: UIState;
                                          },
                                          {},
                                          {},
                                          {},
                                          string,
                                          ComponentProvideOptions,
                                          true,
                                          {},
                                          any
                                      >;
                                  },
                                  {},
                                  string,
                                  ComponentProvideOptions,
                                  true,
                                  {},
                                  any
                              >;
                          } & GlobalComponents,
                          GlobalDirectives,
                          string,
                          {},
                          any,
                          ComponentProvideOptions,
                          {
                              P: {};
                              B: {};
                              D: {};
                              C: {};
                              M: {};
                              Defaults: {};
                          },
                          Readonly<
                              ExtractPropTypes<{
                                  beforeChange: {
                                      type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                      default: null;
                                  };
                                  checked: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  radioLabel: {
                                      type: StringConstructor;
                                      default: string;
                                  };
                                  radioValue: {
                                      type: null;
                                      required: true;
                                  };
                                  size: {
                                      type: PropType<Size>;
                                      default: string;
                                  };
                                  modelValue: {
                                      type: null;
                                      default: null;
                                  };
                                  width: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  grid: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  label: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  messages: {
                                      type: PropType<Message<any>[]>;
                                      default: () => Message<any>[];
                                  };
                                  name: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noDefaultRules: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  readonly: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  rules: {
                                      type: PropType<Rule<any>[]>;
                                      default: () => Rule<any>[];
                                  };
                                  state: {
                                      type: PropType<UIState>;
                                      default: UIState;
                                  };
                                  changed: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  valid: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  disabled: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  hidden: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  id: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noLabel: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  noMessages: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  required: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  styleSet: {
                                      type: PropType<string | VsRadioStyleSet>;
                                  };
                                  colorScheme: {
                                      type: PropType<ColorScheme>;
                                  };
                              }>
                          > &
                              Readonly<{
                                  onFocus?: ((...args: any[]) => any) | undefined;
                                  onBlur?: ((...args: any[]) => any) | undefined;
                                  onChange?: ((...args: any[]) => any) | undefined;
                                  onToggle?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                  onClear?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                  'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                              }>,
                          {
                              computedId: ComputedRef<string>;
                              radioRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                              isChecked: ComputedRef<boolean>;
                              colorSchemeClass: ComputedRef<string>;
                              computedState: ComputedRef<UIState>;
                              componentStyleSet: ComputedRef<Partial<VsRadioStyleSet>>;
                              styleSetVariables: ComputedRef<Record<string, string>>;
                              classObj: ComputedRef<{
                                  'vs-disabled': boolean;
                                  'vs-focus-visible': boolean;
                                  'vs-readonly': boolean;
                              }>;
                              sizeClass: ComputedRef<string>;
                              stateBoxClasses: ComputedRef<{}>;
                              computedDisabled: ComputedRef<boolean>;
                              computedReadonly: ComputedRef<boolean>;
                              inputValue: Ref<any, any>;
                              computedMessages: ComputedRef<StateMessage<UIState>[]>;
                              shake: Ref<boolean, boolean>;
                              validate: () => boolean;
                              clear: () => void;
                              reset: () => void;
                              onToggle: (event: Event) => Promise<void>;
                              onFocus: (e: FocusEvent) => void;
                              onBlur: (e: FocusEvent) => void;
                              focus: () => void;
                              blur: () => void;
                              convertToString: (value: any) => string;
                          },
                          {},
                          {},
                          {},
                          {
                              label: string;
                              messages: Message<any>[];
                              name: string;
                              noDefaultRules: boolean;
                              readonly: boolean;
                              rules: Rule<any>[];
                              state: UIState;
                              changed: boolean;
                              valid: boolean;
                              disabled: boolean;
                              hidden: boolean;
                              id: string;
                              noLabel: boolean;
                              noMessages: boolean;
                              required: boolean;
                              size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                              modelValue: any;
                              beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                              checked: boolean;
                              radioLabel: string;
                          }
                      >[]
                    | null
                >
            >;
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsRadioSetStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                'vs-vertical': boolean;
            }>;
            sizeClass: ComputedRef<string>;
            computedId: ComputedRef<string>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            computedState: ComputedRef<UIState>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            shake: Ref<boolean, boolean>;
            inputValue: Ref<any, any>;
            getOptionLabel: (option: any) => string;
            getOptionValue: (option: any) => any;
            resolvedName: ComputedRef<string>;
            onRadioUpdate: (value: any) => void;
            onFocus: (option: any, event: FocusEvent) => void;
            onBlur: (option: any, event: FocusEvent) => void;
            validate: () => boolean;
            clear: () => void;
            reset: () => void;
            focus: () => void;
            blur: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
        'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                beforeChange: {
                    type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                    default: null;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modelValue: {
                    type: null;
                    default: null;
                };
                options: {
                    type: PropType<any[]>;
                    default: () => never[];
                };
                optionLabel: {
                    type: StringConstructor;
                    default: string;
                };
                optionValue: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<any>[]>;
                    default: () => Message<any>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<any>[]>;
                    default: () => Rule<any>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsRadioSetStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            messages: Message<any>[];
            name: string;
            noDefaultRules: boolean;
            readonly: boolean;
            rules: Rule<any>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            vertical: boolean;
            modelValue: any;
            beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
            options: any[];
            optionLabel: string;
            optionValue: string;
        },
        {},
        {
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsRadio: DefineComponent<
                ExtractPropTypes<{
                    beforeChange: {
                        type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                        default: null;
                    };
                    checked: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    radioLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    radioValue: {
                        type: null;
                        required: true;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    modelValue: {
                        type: null;
                        default: null;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<any>[]>;
                        default: () => Message<any>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<any>[]>;
                        default: () => Rule<any>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsRadioStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    computedId: ComputedRef<string>;
                    radioRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                    isChecked: ComputedRef<boolean>;
                    colorSchemeClass: ComputedRef<string>;
                    computedState: ComputedRef<UIState>;
                    componentStyleSet: ComputedRef<Partial<VsRadioStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    classObj: ComputedRef<{
                        'vs-disabled': boolean;
                        'vs-focus-visible': boolean;
                        'vs-readonly': boolean;
                    }>;
                    sizeClass: ComputedRef<string>;
                    stateBoxClasses: ComputedRef<{}>;
                    computedDisabled: ComputedRef<boolean>;
                    computedReadonly: ComputedRef<boolean>;
                    inputValue: Ref<any, any>;
                    computedMessages: ComputedRef<StateMessage<UIState>[]>;
                    shake: Ref<boolean, boolean>;
                    validate: () => boolean;
                    clear: () => void;
                    reset: () => void;
                    onToggle: (event: Event) => Promise<void>;
                    onFocus: (e: FocusEvent) => void;
                    onBlur: (e: FocusEvent) => void;
                    focus: () => void;
                    blur: () => void;
                    convertToString: (value: any) => string;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                (
                    | 'blur'
                    | 'change'
                    | 'focus'
                    | 'toggle'
                    | 'clear'
                    | 'update:modelValue'
                    | 'update:changed'
                    | 'update:valid'
                )[],
                | 'blur'
                | 'change'
                | 'focus'
                | 'toggle'
                | 'clear'
                | 'update:modelValue'
                | 'update:changed'
                | 'update:valid',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        beforeChange: {
                            type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                            default: null;
                        };
                        checked: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        radioLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        radioValue: {
                            type: null;
                            required: true;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        modelValue: {
                            type: null;
                            default: null;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        messages: {
                            type: PropType<Message<any>[]>;
                            default: () => Message<any>[];
                        };
                        name: {
                            type: typeof String;
                            default: string;
                        };
                        noDefaultRules: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        readonly: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        rules: {
                            type: PropType<Rule<any>[]>;
                            default: () => Rule<any>[];
                        };
                        state: {
                            type: PropType<UIState>;
                            default: UIState;
                        };
                        changed: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        valid: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsRadioStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onChange?: ((...args: any[]) => any) | undefined;
                        onToggle?: ((...args: any[]) => any) | undefined;
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        onClear?: ((...args: any[]) => any) | undefined;
                        'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                        'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    label: string;
                    messages: Message<any>[];
                    name: string;
                    noDefaultRules: boolean;
                    readonly: boolean;
                    rules: Rule<any>[];
                    state: UIState;
                    changed: boolean;
                    valid: boolean;
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    modelValue: any;
                    beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                    checked: boolean;
                    radioLabel: string;
                },
                {},
                {
                    VsInputWrapper: DefineComponent<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            needToShake: Ref<boolean, boolean>;
                            componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                groupLabel: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                messages: {
                                    type: PropType<StateMessage<UIState>[]>;
                                    default: () => never[];
                                };
                                shake: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputWrapperStyleSet>;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            label: string;
                            messages: StateMessage<UIState>[];
                            disabled: boolean;
                            hidden: boolean;
                            id: string;
                            noLabel: boolean;
                            noMessages: boolean;
                            required: boolean;
                            groupLabel: boolean;
                            shake: boolean;
                        },
                        {},
                        {
                            VsResponsive: DefineComponent<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>,
                                {
                                    responsiveClasses: ComputedRef<string[]>;
                                    responsiveStyles: ComputedRef<Record<string, string>>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        tag: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    tag: string;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsMessage: DefineComponent<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>,
                                {
                                    colorClass: ComputedRef<
                                        'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                    >;
                                    icon: ComputedRef<Component>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        state: {
                                            type: PropType<UIState>;
                                            default: string;
                                        };
                                        text: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsMessageStyleSet>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    text: string;
                                    state: UIState;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsRender: DefineComponent<
        ExtractPropTypes<{
            content: {
                type: PropType<string | Component>;
                required: true;
            };
            componentProps: {
                type: PropType<Record<string, any>>;
                default: () => {};
            };
        }>,
        () => VNode<
            RendererNode,
            RendererElement,
            {
                [key: string]: any;
            }
        >,
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                content: {
                    type: PropType<string | Component>;
                    required: true;
                };
                componentProps: {
                    type: PropType<Record<string, any>>;
                    default: () => {};
                };
            }>
        > &
            Readonly<{}>,
        {
            componentProps: Record<string, any>;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsResponsive: DefineComponent<
        ExtractPropTypes<{
            tag: {
                type: StringConstructor;
                default: string;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>,
        {
            responsiveClasses: ComputedRef<string[]>;
            responsiveStyles: ComputedRef<Record<string, string>>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>
        > &
            Readonly<{}>,
        {
            tag: string;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsSearchInput: DefineComponent<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            placeholder: {
                type: StringConstructor;
                default: string;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            useCaseSensitive: {
                type: BooleanConstructor;
                default: boolean;
            };
            useRegex: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: StringConstructor;
                default: string;
            };
            caseSensitive: {
                type: BooleanConstructor;
                default: boolean;
            };
            regex: {
                type: BooleanConstructor;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            styleSet: {
                type: PropType<string | VsSearchInputStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            inputRef: Readonly<ShallowRef<VsInputRef | null>>;
            searchText: Ref<string, string>;
            isCaseSensitiveOn: Ref<boolean, boolean>;
            isRegexOn: Ref<boolean, boolean>;
            computedColorScheme: ComputedRef<
                | 'brown'
                | 'red'
                | 'orange'
                | 'amber'
                | 'yellow'
                | 'lime'
                | 'green'
                | 'emerald'
                | 'teal'
                | 'cyan'
                | 'sky'
                | 'blue'
                | 'indigo'
                | 'violet'
                | 'purple'
                | 'fuchsia'
                | 'pink'
                | 'rose'
                | 'gray'
                | 'none'
                | undefined
            >;
            componentStyleSet: ComputedRef<Partial<VsSearchInputStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            onInputChange: (value: string | number | null) => void;
            match: (text: string) => boolean;
            focus: () => void;
            blur: () => void;
            select: () => void;
            clear: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex')[],
        'search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                placeholder: {
                    type: StringConstructor;
                    default: string;
                };
                readonly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                useCaseSensitive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                useRegex: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modelValue: {
                    type: StringConstructor;
                    default: string;
                };
                caseSensitive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                regex: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                styleSet: {
                    type: PropType<string | VsSearchInputStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onSearch?: ((...args: any[]) => any) | undefined;
                'onUpdate:caseSensitive'?: ((...args: any[]) => any) | undefined;
                'onUpdate:regex'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            placeholder: string;
            readonly: boolean;
            disabled: boolean;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            modelValue: string;
            useCaseSensitive: boolean;
            useRegex: boolean;
            caseSensitive: boolean;
            regex: boolean;
        },
        {},
        {
            VsInput: DefineComponent<
                ExtractPropTypes<{
                    autocomplete: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    noClear: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<VsInputType>;
                        default: string;
                    };
                    modelValue: {
                        type: PropType<VsInputValueType>;
                        default: null;
                    };
                    modelModifiers: {
                        type: PropType<StringModifiers>;
                        default: () => {};
                    };
                    min: {
                        type: PropType<number | string>;
                        default: string | number;
                        validator: (value: number | string) => boolean;
                    };
                    max: {
                        type: PropType<number | string>;
                        default: string | number;
                        validator: (value: number | string) => boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<VsInputValueType>[]>;
                        default: () => Message<VsInputValueType>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    placeholder: {
                        type: typeof String;
                        default: string;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<VsInputValueType>[]>;
                        default: () => Rule<VsInputValueType>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                }>,
                {
                    inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                    classObj: ComputedRef<{
                        [x: string]: boolean;
                        'vs-focus-visible': boolean;
                        'vs-focus-within': boolean;
                        'vs-disabled': boolean;
                        'vs-readonly': boolean;
                    }>;
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    inputValue: Ref<VsInputValueType, VsInputValueType>;
                    computedMessages: ComputedRef<StateMessage<UIState>[]>;
                    computedDisabled: ComputedRef<boolean>;
                    computedReadonly: ComputedRef<boolean>;
                    renderClearButton: ComputedRef<boolean>;
                    shake: Ref<boolean, boolean>;
                    stateBoxClasses: ComputedRef<{}>;
                    computedId: ComputedRef<string>;
                    onInput: (event: Event) => void;
                    focus: () => void;
                    blur: () => void;
                    select: () => void;
                    clear: () => void;
                    reset: () => void;
                    onFocus: (e: FocusEvent) => void;
                    onBlur: (e: FocusEvent) => void;
                    validate: () => boolean;
                    clearWithFocus: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
                'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        autocomplete: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        noClear: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<VsInputType>;
                            default: string;
                        };
                        modelValue: {
                            type: PropType<VsInputValueType>;
                            default: null;
                        };
                        modelModifiers: {
                            type: PropType<StringModifiers>;
                            default: () => {};
                        };
                        min: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        max: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        messages: {
                            type: PropType<Message<VsInputValueType>[]>;
                            default: () => Message<VsInputValueType>[];
                        };
                        name: {
                            type: typeof String;
                            default: string;
                        };
                        noDefaultRules: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        placeholder: {
                            type: typeof String;
                            default: string;
                        };
                        readonly: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        rules: {
                            type: PropType<Rule<VsInputValueType>[]>;
                            default: () => Rule<VsInputValueType>[];
                        };
                        state: {
                            type: PropType<UIState>;
                            default: UIState;
                        };
                        changed: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        valid: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                    }>
                > &
                    Readonly<{
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onChange?: ((...args: any[]) => any) | undefined;
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        onClear?: ((...args: any[]) => any) | undefined;
                        'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                        'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    label: string;
                    messages: Message<VsInputValueType>[];
                    name: string;
                    noDefaultRules: boolean;
                    placeholder: string;
                    readonly: boolean;
                    rules: Rule<VsInputValueType>[];
                    state: UIState;
                    changed: boolean;
                    valid: boolean;
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    min: string | number;
                    max: string | number;
                    type: VsInputType;
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    modelValue: VsInputValueType;
                    autocomplete: boolean;
                    noClear: boolean;
                    modelModifiers: StringModifiers;
                },
                {},
                {
                    VsInputWrapper: DefineComponent<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            needToShake: Ref<boolean, boolean>;
                            componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                groupLabel: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                messages: {
                                    type: PropType<StateMessage<UIState>[]>;
                                    default: () => never[];
                                };
                                shake: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputWrapperStyleSet>;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            label: string;
                            messages: StateMessage<UIState>[];
                            disabled: boolean;
                            hidden: boolean;
                            id: string;
                            noLabel: boolean;
                            noMessages: boolean;
                            required: boolean;
                            groupLabel: boolean;
                            shake: boolean;
                        },
                        {},
                        {
                            VsResponsive: DefineComponent<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>,
                                {
                                    responsiveClasses: ComputedRef<string[]>;
                                    responsiveStyles: ComputedRef<Record<string, string>>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        tag: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    tag: string;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsMessage: DefineComponent<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>,
                                {
                                    colorClass: ComputedRef<
                                        'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                    >;
                                    icon: ComputedRef<Component>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        state: {
                                            type: PropType<UIState>;
                                            default: string;
                                        };
                                        text: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsMessageStyleSet>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    text: string;
                                    state: UIState;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    XIcon: LucideIcon;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsToggle: DefineComponent<
                ExtractPropTypes<{
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsToggleStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    toggle: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('toggle' | 'update:modelValue')[],
                'toggle' | 'update:modelValue',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        modelValue: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsToggleStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        onToggle?: ((...args: any[]) => any) | undefined;
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    circle: boolean;
                    disabled: boolean;
                    type: 'button' | 'reset' | 'submit';
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    outline: boolean;
                    primary: boolean;
                    modelValue: boolean;
                    ghost: boolean;
                    loading: boolean;
                    responsive: boolean;
                },
                {},
                {
                    VsButton: DefineComponent<
                        ExtractPropTypes<{
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsButtonStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                            classObj: ComputedRef<{
                                [x: string]: boolean;
                                'vs-focus-visible': boolean;
                                'vs-circle': boolean;
                                'vs-disabled': boolean;
                                'vs-ghost': boolean;
                                'vs-loading-state': boolean;
                                'vs-outline': boolean;
                                'vs-primary': boolean;
                                'vs-responsive': boolean;
                            }>;
                            buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                            componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                circle: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                responsive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<'button' | 'submit' | 'reset'>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsButtonStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            circle: boolean;
                            disabled: boolean;
                            type: 'button' | 'reset' | 'submit';
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            outline: boolean;
                            primary: boolean;
                            ghost: boolean;
                            loading: boolean;
                            responsive: boolean;
                        },
                        {},
                        {
                            VsLoading: DefineComponent<
                                ExtractPropTypes<{
                                    width: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    height: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    styleSet: {
                                        type: PropType<string | VsLoadingStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    colorSchemeClass: ComputedRef<string>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        width: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        height: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        styleSet: {
                                            type: PropType<string | VsLoadingStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {},
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsSelect: DefineComponent<
        ExtractPropTypes<{
            closableChips: {
                type: BooleanConstructor;
                default: boolean;
            };
            collapseChips: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            optionsDisabled: {
                type: PropType<boolean | ((option: any, index: number, options: any[]) => boolean)>;
                default: boolean;
            };
            selectAll: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: null;
                default: null;
            };
            search: {
                type: PropType<SearchProps>;
                default: boolean;
                validator: (value: SearchProps) => boolean;
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            groupBy: {
                type: PropType<(option: any, index: number) => string | null> | null;
                default: null;
            };
            groupOrder: {
                type: PropType<string[]>;
                default: () => never[];
            };
            options: {
                type: PropType<any[]>;
                default: () => never[];
            };
            optionLabel: {
                type: StringConstructor;
                default: string;
            };
            optionValue: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsSelectStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>,
        {
            triggerRef: Readonly<ShallowRef<VsSelectTriggerRef | null>>;
            searchInputRef: Readonly<ShallowRef<VsSearchInputRef | null>>;
            optionsListRef: Readonly<ShallowRef<VsGroupedListRef | null>>;
            triggerId: ComputedRef<string>;
            optionsId: ComputedRef<string>;
            isOpen: Ref<boolean, boolean>;
            inputValue: Ref<any, any>;
            colorSchemeClass: ComputedRef<string>;
            sizeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentStyleSet: ComputedRef<Partial<VsSelectStyleSet>>;
            classObj: ComputedRef<{
                [x: string]: boolean;
                'vs-disabled': boolean;
                'vs-readonly': boolean;
            }>;
            computedId: ComputedRef<string>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            computedState: ComputedRef<UIState>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            filteredOptions: ComputedRef<OptionItem[]>;
            shake: Ref<boolean, boolean>;
            openOptions: () => void;
            closeOptions: () => void;
            isSelected: (optionId: string) => boolean;
            toggleSelectAll: () => void;
            isUsingSearch: ComputedRef<boolean>;
            searchProps: ComputedRef<{
                useRegex: boolean;
                useCaseSensitive: boolean;
                placeholder: string;
            }>;
            toggleOpen: () => void;
            selectOptionItem: (optionItem: OptionItem) => void;
            isSelectedAll: ComputedRef<boolean>;
            computedColorScheme: ComputedRef<
                | 'brown'
                | 'red'
                | 'orange'
                | 'amber'
                | 'yellow'
                | 'lime'
                | 'green'
                | 'emerald'
                | 'teal'
                | 'cyan'
                | 'sky'
                | 'blue'
                | 'indigo'
                | 'violet'
                | 'purple'
                | 'fuchsia'
                | 'pink'
                | 'rose'
                | 'gray'
                | 'none'
                | undefined
            >;
            onFocus: (e: FocusEvent) => void;
            onBlur: (e: FocusEvent) => void;
            focus: () => void;
            blur: () => void;
            validate: () => boolean;
            clear: () => void;
            reset: () => void;
            isEmpty: ComputedRef<boolean>;
            selectedOptions: ComputedRef<OptionItem[]>;
            deselectOption: (optionId: string) => void;
            getOptionStyleSet: (optionId: string) => CSSProperties;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        (
            | 'blur'
            | 'change'
            | 'close'
            | 'focus'
            | 'open'
            | 'clear'
            | 'update:modelValue'
            | 'update:changed'
            | 'update:valid'
            | 'click-option'
        )[],
        | 'blur'
        | 'change'
        | 'close'
        | 'focus'
        | 'open'
        | 'clear'
        | 'update:modelValue'
        | 'update:changed'
        | 'update:valid'
        | 'click-option',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                closableChips: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                collapseChips: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                noClear: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                optionsDisabled: {
                    type: PropType<boolean | ((option: any, index: number, options: any[]) => boolean)>;
                    default: boolean;
                };
                selectAll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                modelValue: {
                    type: null;
                    default: null;
                };
                search: {
                    type: PropType<SearchProps>;
                    default: boolean;
                    validator: (value: SearchProps) => boolean;
                };
                min: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                max: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                groupBy: {
                    type: PropType<(option: any, index: number) => string | null> | null;
                    default: null;
                };
                groupOrder: {
                    type: PropType<string[]>;
                    default: () => never[];
                };
                options: {
                    type: PropType<any[]>;
                    default: () => never[];
                };
                optionLabel: {
                    type: StringConstructor;
                    default: string;
                };
                optionValue: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsSelectStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<any>[]>;
                    default: () => Message<any>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                placeholder: {
                    type: typeof String;
                    default: string;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<any>[]>;
                    default: () => Rule<any>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
            }>
        > &
            Readonly<{
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                onClose?: ((...args: any[]) => any) | undefined;
                onOpen?: ((...args: any[]) => any) | undefined;
                'onClick-option'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            search: SearchProps;
            messages: Message<any>[];
            name: string;
            noDefaultRules: boolean;
            placeholder: string;
            readonly: boolean;
            rules: Rule<any>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            min: string | number;
            max: string | number;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            multiple: boolean;
            modelValue: any;
            options: any[];
            optionLabel: string;
            optionValue: string;
            noClear: boolean;
            groupBy: (option: any, index: number) => string | null;
            groupOrder: string[];
            collapseChips: boolean;
            closableChips: boolean;
            optionsDisabled: boolean | ((option: any, index: number, options: any[]) => boolean);
            selectAll: boolean;
        },
        {},
        {
            VsFloating: DefineComponent<
                ExtractPropTypes<{
                    followWidth: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    overlayId: {
                        type: StringConstructor;
                        default: string;
                    };
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    target: {
                        type: StringConstructor;
                        required: boolean;
                        default: string;
                    };
                    align: {
                        type: PropType<Alignment>;
                        default: 'start' | 'center' | 'end';
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    enterDelay: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    leaveDelay: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    margin: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    noAnimation: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placement: {
                        type: PropType<Placement>;
                        default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                    };
                }>,
                {
                    floatingRef: Readonly<ShallowRef<HTMLElement | null>>;
                    computedPlacement: Ref<
                        'top' | 'right' | 'bottom' | 'left' | 'middle' | null,
                        'top' | 'right' | 'bottom' | 'left' | 'middle' | null
                    >;
                    isVisible: Ref<boolean, boolean>;
                    isFloated: Ref<boolean, boolean>;
                    animationClass: ComputedRef<string | null>;
                    floatingStyle: ComputedRef<
                        | {
                              animationDelay?: undefined;
                          }
                        | {
                              animationDelay: string;
                          }
                    >;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                'update:modelValue'[],
                'update:modelValue',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        followWidth: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        overlayId: {
                            type: StringConstructor;
                            default: string;
                        };
                        modelValue: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        target: {
                            type: StringConstructor;
                            required: boolean;
                            default: string;
                        };
                        align: {
                            type: PropType<Alignment>;
                            default: 'start' | 'center' | 'end';
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        enterDelay: {
                            type: (StringConstructor | NumberConstructor)[];
                            default: number;
                        };
                        leaveDelay: {
                            type: (StringConstructor | NumberConstructor)[];
                            default: number;
                        };
                        margin: {
                            type: (StringConstructor | NumberConstructor)[];
                            default: number;
                        };
                        noAnimation: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        placement: {
                            type: PropType<Placement>;
                            default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                        };
                    }>
                > &
                    Readonly<{
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    disabled: boolean;
                    margin: string | number;
                    modelValue: boolean;
                    target: string;
                    placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                    overlayId: string;
                    followWidth: boolean;
                    align: 'start' | 'center' | 'end';
                    enterDelay: string | number;
                    leaveDelay: string | number;
                    noAnimation: boolean;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsSearchInput: DefineComponent<
                ExtractPropTypes<{
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: string;
                    };
                    readonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    useCaseSensitive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    useRegex: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: string;
                    };
                    caseSensitive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    regex: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    styleSet: {
                        type: PropType<string | VsSearchInputStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    inputRef: Readonly<ShallowRef<VsInputRef | null>>;
                    searchText: Ref<string, string>;
                    isCaseSensitiveOn: Ref<boolean, boolean>;
                    isRegexOn: Ref<boolean, boolean>;
                    computedColorScheme: ComputedRef<
                        | 'brown'
                        | 'red'
                        | 'orange'
                        | 'amber'
                        | 'yellow'
                        | 'lime'
                        | 'green'
                        | 'emerald'
                        | 'teal'
                        | 'cyan'
                        | 'sky'
                        | 'blue'
                        | 'indigo'
                        | 'violet'
                        | 'purple'
                        | 'fuchsia'
                        | 'pink'
                        | 'rose'
                        | 'gray'
                        | 'none'
                        | undefined
                    >;
                    componentStyleSet: ComputedRef<Partial<VsSearchInputStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    onInputChange: (value: string | number | null) => void;
                    match: (text: string) => boolean;
                    focus: () => void;
                    blur: () => void;
                    select: () => void;
                    clear: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex')[],
                'search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        placeholder: {
                            type: StringConstructor;
                            default: string;
                        };
                        readonly: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        useCaseSensitive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        useRegex: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        modelValue: {
                            type: StringConstructor;
                            default: string;
                        };
                        caseSensitive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        regex: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        styleSet: {
                            type: PropType<string | VsSearchInputStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        onSearch?: ((...args: any[]) => any) | undefined;
                        'onUpdate:caseSensitive'?: ((...args: any[]) => any) | undefined;
                        'onUpdate:regex'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    placeholder: string;
                    readonly: boolean;
                    disabled: boolean;
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    modelValue: string;
                    useCaseSensitive: boolean;
                    useRegex: boolean;
                    caseSensitive: boolean;
                    regex: boolean;
                },
                {},
                {
                    VsInput: DefineComponent<
                        ExtractPropTypes<{
                            autocomplete: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            noClear: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<VsInputType>;
                                default: string;
                            };
                            modelValue: {
                                type: PropType<VsInputValueType>;
                                default: null;
                            };
                            modelModifiers: {
                                type: PropType<StringModifiers>;
                                default: () => {};
                            };
                            min: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            max: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            messages: {
                                type: PropType<Message<VsInputValueType>[]>;
                                default: () => Message<VsInputValueType>[];
                            };
                            name: {
                                type: typeof String;
                                default: string;
                            };
                            noDefaultRules: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            placeholder: {
                                type: typeof String;
                                default: string;
                            };
                            readonly: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            rules: {
                                type: PropType<Rule<VsInputValueType>[]>;
                                default: () => Rule<VsInputValueType>[];
                            };
                            state: {
                                type: PropType<UIState>;
                                default: UIState;
                            };
                            changed: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            valid: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                        }>,
                        {
                            inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                            classObj: ComputedRef<{
                                [x: string]: boolean;
                                'vs-focus-visible': boolean;
                                'vs-focus-within': boolean;
                                'vs-disabled': boolean;
                                'vs-readonly': boolean;
                            }>;
                            colorSchemeClass: ComputedRef<string>;
                            componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                            inputValue: Ref<VsInputValueType, VsInputValueType>;
                            computedMessages: ComputedRef<StateMessage<UIState>[]>;
                            computedDisabled: ComputedRef<boolean>;
                            computedReadonly: ComputedRef<boolean>;
                            renderClearButton: ComputedRef<boolean>;
                            shake: Ref<boolean, boolean>;
                            stateBoxClasses: ComputedRef<{}>;
                            computedId: ComputedRef<string>;
                            onInput: (event: Event) => void;
                            focus: () => void;
                            blur: () => void;
                            select: () => void;
                            clear: () => void;
                            reset: () => void;
                            onFocus: (e: FocusEvent) => void;
                            onBlur: (e: FocusEvent) => void;
                            validate: () => boolean;
                            clearWithFocus: () => void;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        (
                            | 'blur'
                            | 'change'
                            | 'focus'
                            | 'clear'
                            | 'update:modelValue'
                            | 'update:changed'
                            | 'update:valid'
                        )[],
                        'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                autocomplete: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                noClear: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<VsInputType>;
                                    default: string;
                                };
                                modelValue: {
                                    type: PropType<VsInputValueType>;
                                    default: null;
                                };
                                modelModifiers: {
                                    type: PropType<StringModifiers>;
                                    default: () => {};
                                };
                                min: {
                                    type: PropType<number | string>;
                                    default: string | number;
                                    validator: (value: number | string) => boolean;
                                };
                                max: {
                                    type: PropType<number | string>;
                                    default: string | number;
                                    validator: (value: number | string) => boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                messages: {
                                    type: PropType<Message<VsInputValueType>[]>;
                                    default: () => Message<VsInputValueType>[];
                                };
                                name: {
                                    type: typeof String;
                                    default: string;
                                };
                                noDefaultRules: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                placeholder: {
                                    type: typeof String;
                                    default: string;
                                };
                                readonly: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                rules: {
                                    type: PropType<Rule<VsInputValueType>[]>;
                                    default: () => Rule<VsInputValueType>[];
                                };
                                state: {
                                    type: PropType<UIState>;
                                    default: UIState;
                                };
                                changed: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                valid: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                            }>
                        > &
                            Readonly<{
                                onFocus?: ((...args: any[]) => any) | undefined;
                                onBlur?: ((...args: any[]) => any) | undefined;
                                onChange?: ((...args: any[]) => any) | undefined;
                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                onClear?: ((...args: any[]) => any) | undefined;
                                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            label: string;
                            messages: Message<VsInputValueType>[];
                            name: string;
                            noDefaultRules: boolean;
                            placeholder: string;
                            readonly: boolean;
                            rules: Rule<VsInputValueType>[];
                            state: UIState;
                            changed: boolean;
                            valid: boolean;
                            disabled: boolean;
                            hidden: boolean;
                            id: string;
                            noLabel: boolean;
                            noMessages: boolean;
                            required: boolean;
                            min: string | number;
                            max: string | number;
                            type: VsInputType;
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            modelValue: VsInputValueType;
                            autocomplete: boolean;
                            noClear: boolean;
                            modelModifiers: StringModifiers;
                        },
                        {},
                        {
                            VsInputWrapper: DefineComponent<
                                ExtractPropTypes<{
                                    groupLabel: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    messages: {
                                        type: PropType<StateMessage<UIState>[]>;
                                        default: () => never[];
                                    };
                                    shake: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsInputWrapperStyleSet>;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>,
                                {
                                    needToShake: Ref<boolean, boolean>;
                                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        groupLabel: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        messages: {
                                            type: PropType<StateMessage<UIState>[]>;
                                            default: () => never[];
                                        };
                                        shake: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsInputWrapperStyleSet>;
                                        };
                                        disabled: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        hidden: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        id: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        label: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noLabel: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        noMessages: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        required: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    label: string;
                                    messages: StateMessage<UIState>[];
                                    disabled: boolean;
                                    hidden: boolean;
                                    id: string;
                                    noLabel: boolean;
                                    noMessages: boolean;
                                    required: boolean;
                                    groupLabel: boolean;
                                    shake: boolean;
                                },
                                {},
                                {
                                    VsResponsive: DefineComponent<
                                        ExtractPropTypes<{
                                            tag: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>,
                                        {
                                            responsiveClasses: ComputedRef<string[]>;
                                            responsiveStyles: ComputedRef<Record<string, string>>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                tag: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            tag: string;
                                        },
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                    VsMessage: DefineComponent<
                                        ExtractPropTypes<{
                                            state: {
                                                type: PropType<UIState>;
                                                default: string;
                                            };
                                            text: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsMessageStyleSet>;
                                            };
                                        }>,
                                        {
                                            colorClass: ComputedRef<
                                                | 'vs-cs-blue'
                                                | 'vs-cs-green'
                                                | 'vs-cs-amber'
                                                | 'vs-cs-red'
                                                | 'vs-cs-default'
                                            >;
                                            icon: ComputedRef<Component>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                state: {
                                                    type: PropType<UIState>;
                                                    default: string;
                                                };
                                                text: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsMessageStyleSet>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            text: string;
                                            state: UIState;
                                        },
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            XIcon: LucideIcon;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsToggle: DefineComponent<
                        ExtractPropTypes<{
                            modelValue: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsToggleStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            toggle: () => void;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        ('toggle' | 'update:modelValue')[],
                        'toggle' | 'update:modelValue',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                modelValue: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                circle: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                responsive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<'button' | 'submit' | 'reset'>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsToggleStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{
                                onToggle?: ((...args: any[]) => any) | undefined;
                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            circle: boolean;
                            disabled: boolean;
                            type: 'button' | 'reset' | 'submit';
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            outline: boolean;
                            primary: boolean;
                            modelValue: boolean;
                            ghost: boolean;
                            loading: boolean;
                            responsive: boolean;
                        },
                        {},
                        {
                            VsButton: DefineComponent<
                                ExtractPropTypes<{
                                    circle: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    ghost: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    loading: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    outline: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    primary: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    responsive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    type: {
                                        type: PropType<'button' | 'submit' | 'reset'>;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsButtonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    colorSchemeClass: ComputedRef<string>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                    classObj: ComputedRef<{
                                        [x: string]: boolean;
                                        'vs-focus-visible': boolean;
                                        'vs-circle': boolean;
                                        'vs-disabled': boolean;
                                        'vs-ghost': boolean;
                                        'vs-loading-state': boolean;
                                        'vs-outline': boolean;
                                        'vs-primary': boolean;
                                        'vs-responsive': boolean;
                                    }>;
                                    buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                    componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        circle: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        ghost: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        loading: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        outline: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        primary: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        responsive: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        type: {
                                            type: PropType<'button' | 'submit' | 'reset'>;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsButtonStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    circle: boolean;
                                    disabled: boolean;
                                    type: 'button' | 'reset' | 'submit';
                                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                    outline: boolean;
                                    primary: boolean;
                                    ghost: boolean;
                                    loading: boolean;
                                    responsive: boolean;
                                },
                                {},
                                {
                                    VsLoading: DefineComponent<
                                        ExtractPropTypes<{
                                            width: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            styleSet: {
                                                type: PropType<string | VsLoadingStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>,
                                        {
                                            colorSchemeClass: ComputedRef<string>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                width: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                height: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsLoadingStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {},
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsCheckbox: DefineComponent<
                ExtractPropTypes<{
                    beforeChange: {
                        type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                        default: null;
                    };
                    checked: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    checkLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    indeterminate: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    multiple: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    trueValue: {
                        type: null;
                        default: boolean;
                    };
                    falseValue: {
                        type: null;
                        default: boolean;
                    };
                    modelValue: {
                        type: null;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<any>[]>;
                        default: () => Message<any>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<any>[]>;
                        default: () => Rule<any>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsCheckboxStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    classObj: ComputedRef<{
                        'vs-checked': boolean;
                        'vs-disabled': boolean;
                        'vs-focus-visible': boolean;
                        'vs-indeterminate': boolean;
                        'vs-readonly': boolean;
                    }>;
                    sizeClass: ComputedRef<string>;
                    stateBoxClasses: ComputedRef<{}>;
                    computedId: ComputedRef<string>;
                    computedDisabled: ComputedRef<boolean>;
                    computedReadonly: ComputedRef<boolean>;
                    computedMessages: ComputedRef<StateMessage<UIState>[]>;
                    computedState: ComputedRef<UIState>;
                    convertToString: (value: any) => string;
                    inputValue: Ref<any, any>;
                    isChecked: ComputedRef<boolean>;
                    shake: Ref<boolean, boolean>;
                    toggle: (e: MouseEvent) => Promise<void>;
                    onFocus: (e: FocusEvent) => void;
                    onBlur: (e: FocusEvent) => void;
                    validate: () => boolean;
                    clear: () => void;
                    reset: () => void;
                    focus: () => void;
                    blur: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                (
                    | 'blur'
                    | 'change'
                    | 'focus'
                    | 'toggle'
                    | 'clear'
                    | 'update:modelValue'
                    | 'update:changed'
                    | 'update:valid'
                )[],
                | 'blur'
                | 'change'
                | 'focus'
                | 'toggle'
                | 'clear'
                | 'update:modelValue'
                | 'update:changed'
                | 'update:valid',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        beforeChange: {
                            type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                            default: null;
                        };
                        checked: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        checkLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        indeterminate: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        multiple: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        trueValue: {
                            type: null;
                            default: boolean;
                        };
                        falseValue: {
                            type: null;
                            default: boolean;
                        };
                        modelValue: {
                            type: null;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        messages: {
                            type: PropType<Message<any>[]>;
                            default: () => Message<any>[];
                        };
                        name: {
                            type: typeof String;
                            default: string;
                        };
                        noDefaultRules: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        readonly: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        rules: {
                            type: PropType<Rule<any>[]>;
                            default: () => Rule<any>[];
                        };
                        state: {
                            type: PropType<UIState>;
                            default: UIState;
                        };
                        changed: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        valid: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsCheckboxStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onChange?: ((...args: any[]) => any) | undefined;
                        onToggle?: ((...args: any[]) => any) | undefined;
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        onClear?: ((...args: any[]) => any) | undefined;
                        'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                        'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    label: string;
                    messages: Message<any>[];
                    name: string;
                    noDefaultRules: boolean;
                    readonly: boolean;
                    rules: Rule<any>[];
                    state: UIState;
                    changed: boolean;
                    valid: boolean;
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    multiple: boolean;
                    modelValue: any;
                    beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                    checked: boolean;
                    checkLabel: string;
                    indeterminate: boolean;
                    trueValue: any;
                    falseValue: any;
                },
                {},
                {
                    VsInputWrapper: DefineComponent<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            needToShake: Ref<boolean, boolean>;
                            componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                groupLabel: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                messages: {
                                    type: PropType<StateMessage<UIState>[]>;
                                    default: () => never[];
                                };
                                shake: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputWrapperStyleSet>;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            label: string;
                            messages: StateMessage<UIState>[];
                            disabled: boolean;
                            hidden: boolean;
                            id: string;
                            noLabel: boolean;
                            noMessages: boolean;
                            required: boolean;
                            groupLabel: boolean;
                            shake: boolean;
                        },
                        {},
                        {
                            VsResponsive: DefineComponent<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>,
                                {
                                    responsiveClasses: ComputedRef<string[]>;
                                    responsiveStyles: ComputedRef<Record<string, string>>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        tag: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    tag: string;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsMessage: DefineComponent<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>,
                                {
                                    colorClass: ComputedRef<
                                        'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                    >;
                                    icon: ComputedRef<Component>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        state: {
                                            type: PropType<UIState>;
                                            default: string;
                                        };
                                        text: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsMessageStyleSet>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    text: string;
                                    state: UIState;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsGroupedList: DefineComponent<
                ExtractPropTypes<{
                    items: {
                        type: PropType<OptionItem[]>;
                        default: () => never[];
                    };
                    groupBy: {
                        type: PropType<(option: any, index: number) => string | null> | null;
                        default: null;
                    };
                    groupOrder: {
                        type: PropType<string[]>;
                        default: () => never[];
                    };
                    styleSet: {
                        type: PropType<string | VsGroupedListStyleSet>;
                    };
                }>,
                {
                    visibleRenderRef: Readonly<ShallowRef<VsVisibleRenderRef | null>>;
                    innerScrollRef: Readonly<ShallowRef<VsInnerScrollRef | null>>;
                    componentStyleSet: ComputedRef<Partial<VsGroupedListStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    groupedItems: ComputedRef<VsGroupedListGroup[]>;
                    emitClickItem: (
                        item: OptionItem,
                        groupedIndex: number,
                        group: VsGroupedListGroup,
                        groupIndex: number,
                    ) => void;
                    scrollToItem: (id: string) => void;
                    hasScroll: () => boolean;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                'click-item'[],
                'click-item',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        items: {
                            type: PropType<OptionItem[]>;
                            default: () => never[];
                        };
                        groupBy: {
                            type: PropType<(option: any, index: number) => string | null> | null;
                            default: null;
                        };
                        groupOrder: {
                            type: PropType<string[]>;
                            default: () => never[];
                        };
                        styleSet: {
                            type: PropType<string | VsGroupedListStyleSet>;
                        };
                    }>
                > &
                    Readonly<{
                        'onClick-item'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    items: OptionItem[];
                    groupBy: (option: any, index: number) => string | null;
                    groupOrder: string[];
                },
                {},
                {
                    VsInnerScroll: DefineComponent<
                        ExtractPropTypes<{
                            hideScroll: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInnerScrollStyleSet>;
                            };
                        }>,
                        {
                            componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                            hasScroll: () => boolean;
                            bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                hideScroll: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInnerScrollStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            hideScroll: boolean;
                        },
                        {},
                        {},
                        {
                            scrollShadow: Directive<HTMLElement, boolean | undefined>;
                        },
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsVisibleRender: DefineComponent<
                        ExtractPropTypes<{
                            selector: {
                                type: StringConstructor;
                                default: null;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            rootMargin: {
                                type: StringConstructor;
                                default: string;
                            };
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            threshold: {
                                type: NumberConstructor;
                                default: number;
                                validator: (value: number) => boolean;
                            };
                        }>,
                        {
                            containerStyle: ComputedRef<
                                | {
                                      height?: undefined;
                                      overflowY?: undefined;
                                  }
                                | {
                                      height: string;
                                      overflowY: string;
                                  }
                            >;
                            scrollToElement: (element: HTMLElement) => void;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                selector: {
                                    type: StringConstructor;
                                    default: null;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                height: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                rootMargin: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                threshold: {
                                    type: NumberConstructor;
                                    default: number;
                                    validator: (value: number) => boolean;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            disabled: boolean;
                            tag: string;
                            selector: string;
                            rootMargin: string;
                            threshold: number;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsSelectTrigger: DefineComponent<
                ExtractPropTypes<{
                    styleSet: {
                        type: PropType<VsSelectStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                    collapseChips: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    closableChips: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    isEmpty: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    isOpen: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    multiple: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    noClear: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: string;
                    };
                    readonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    selectedOptions: {
                        type: PropType<OptionItem[]>;
                        default: () => never[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: string;
                    };
                }>,
                {
                    triggerRef: Readonly<ShallowRef<HTMLElement | null>>;
                    stateBoxClasses: ComputedRef<{}>;
                    renderClearButton: ComputedRef<boolean>;
                    displayLabel: ComputedRef<string>;
                    triggerClassObj: ComputedRef<{
                        'vs-focusable': boolean;
                        'vs-focus-within': boolean;
                    }>;
                    componentStyleSet: ComputedRef<Partial<VsSelectStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    focus: () => void;
                    blur: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('click' | 'blur' | 'focus' | 'clear' | 'deselect')[],
                'click' | 'blur' | 'focus' | 'clear' | 'deselect',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        styleSet: {
                            type: PropType<VsSelectStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                        collapseChips: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        closableChips: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        isEmpty: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        isOpen: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        multiple: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        noClear: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        placeholder: {
                            type: StringConstructor;
                            default: string;
                        };
                        readonly: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        selectedOptions: {
                            type: PropType<OptionItem[]>;
                            default: () => never[];
                        };
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                    }>
                > &
                    Readonly<{
                        onFocus?: ((...args: any[]) => any) | undefined;
                        onBlur?: ((...args: any[]) => any) | undefined;
                        onClick?: ((...args: any[]) => any) | undefined;
                        onClear?: ((...args: any[]) => any) | undefined;
                        onDeselect?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    placeholder: string;
                    readonly: boolean;
                    state: UIState;
                    disabled: boolean;
                    multiple: boolean;
                    isOpen: boolean;
                    noClear: boolean;
                    collapseChips: boolean;
                    closableChips: boolean;
                    isEmpty: boolean;
                    selectedOptions: OptionItem[];
                },
                {},
                {
                    VsChip: DefineComponent<
                        ExtractPropTypes<{
                            closable: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsChipStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            componentStyleSet: ComputedRef<Partial<VsChipStyleSet>>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                            classObj: ComputedRef<{
                                [x: string]: boolean;
                                'vs-outline': boolean;
                                'vs-primary': boolean;
                            }>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        'close'[],
                        'close',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                closable: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsChipStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{
                                onClose?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            outline: boolean;
                            primary: boolean;
                            closable: boolean;
                        },
                        {},
                        {
                            XIcon: LucideIcon;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    ChevronDownIcon: LucideIcon;
                    XIcon: LucideIcon;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsSkeleton: DefineComponent<
        ExtractPropTypes<{
            styleSet: {
                type: PropType<string | VsSkeletonStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsSkeletonStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                styleSet: {
                    type: PropType<string | VsSkeletonStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {},
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsSteps: DefineComponent<
        ExtractPropTypes<{
            disabled: {
                type: PropType<boolean | ((step: string, index: number) => boolean)>;
                default: boolean;
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            noLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            steps: {
                type: PropType<string[]>;
                default: () => never[];
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: NumberConstructor;
                default: number;
            };
            styleSet: {
                type: PropType<string | VsStepsStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsStepsStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            trackStyleSet: ComputedRef<CSSProperties>;
            progressStyleSet: ComputedRef<CSSProperties>;
            getStepStyleSet: (index: number) => CSSProperties;
            getLabelStyleSet: (index: number) => CSSProperties;
            selectedIndex: Ref<number, number>;
            isPrevious: (index: number) => boolean;
            isSelected: (index: number) => boolean;
            isDisabled: (index: number) => boolean;
            selectStep: (index: number) => void;
            handleKeydown: (e: KeyboardEvent, isVertical: boolean) => void;
            stepRefs: Ref<HTMLElement[], HTMLElement[]>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('change' | 'update:modelValue')[],
        'change' | 'update:modelValue',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                disabled: {
                    type: PropType<boolean | ((step: string, index: number) => boolean)>;
                    default: boolean;
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                noLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                steps: {
                    type: PropType<string[]>;
                    default: () => never[];
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modelValue: {
                    type: NumberConstructor;
                    default: number;
                };
                styleSet: {
                    type: PropType<string | VsStepsStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>
        > &
            Readonly<{
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            disabled: boolean | ((step: string, index: number) => boolean);
            noLabel: boolean;
            vertical: boolean;
            modelValue: number;
            steps: string[];
        },
        {},
        {
            VsResponsive: DefineComponent<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    responsiveClasses: ComputedRef<string[]>;
                    responsiveStyles: ComputedRef<Record<string, string>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsSwitch: DefineComponent<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any) => Promise<boolean> | null>;
                default: null;
            };
            checked: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            falseLabel: {
                type: StringConstructor;
                default: string;
            };
            falseValue: {
                type: null;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            trueLabel: {
                type: StringConstructor;
                default: string;
            };
            trueValue: {
                type: null;
                default: boolean;
            };
            modelValue: {
                type: null;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsSwitchStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            switchRef: Readonly<ShallowRef<HTMLInputElement | null>>;
            colorSchemeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                [x: string]: boolean;
                'vs-checked': boolean;
                'vs-disabled': boolean;
                'vs-readonly': boolean;
            }>;
            stateBoxClasses: ComputedRef<{}>;
            computedId: ComputedRef<string>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            computedState: ComputedRef<UIState>;
            componentStyleSet: ComputedRef<Partial<VsSwitchStyleSet>>;
            inputValue: Ref<any, any>;
            isChecked: ComputedRef<boolean>;
            shake: Ref<boolean, boolean>;
            getSwitchButtonStyle: () => CSSProperties;
            onChange: () => Promise<void>;
            onFocus: (e: FocusEvent) => void;
            onBlur: (e: FocusEvent) => void;
            validate: () => boolean;
            clear: () => void;
            reset: () => void;
            focus: () => void;
            blur: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
        'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                beforeChange: {
                    type: PropType<(from: any, to: any) => Promise<boolean> | null>;
                    default: null;
                };
                checked: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                falseLabel: {
                    type: StringConstructor;
                    default: string;
                };
                falseValue: {
                    type: null;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                trueLabel: {
                    type: StringConstructor;
                    default: string;
                };
                trueValue: {
                    type: null;
                    default: boolean;
                };
                modelValue: {
                    type: null;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<any>[]>;
                    default: () => Message<any>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<any>[]>;
                    default: () => Rule<any>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsSwitchStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            messages: Message<any>[];
            name: string;
            noDefaultRules: boolean;
            readonly: boolean;
            rules: Rule<any>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            multiple: boolean;
            modelValue: any;
            beforeChange: (from: any, to: any) => Promise<boolean> | null;
            checked: boolean;
            trueValue: any;
            falseValue: any;
            falseLabel: string;
            trueLabel: string;
        },
        {},
        {
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsTable: DefineComponent<
        ExtractPropTypes<{
            columns: {
                type: PropType<VsTableColumnDef[] | string[]>;
                default: () => never[];
            };
            items: {
                type: PropType<VsTableItem[]>;
                default: () => never[];
                validator: (value: VsTableItem[]) => boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            noVirtualScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            stickyHeader: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            serverMode: {
                type: BooleanConstructor;
                default: boolean;
                validator: (serverMode: boolean, props: unknown) => boolean;
            };
            draggable: {
                type: BooleanConstructor;
                default: boolean;
            };
            selectable: {
                type: PropType<boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean)>;
                default: boolean;
            };
            expandable: {
                type: PropType<boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean)>;
                default: boolean;
            };
            state: {
                type: PropType<UIState | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => UIState)>;
                default: string;
            };
            pagination: {
                type: PropType<boolean | VsTablePaginationOptions>;
                default: boolean;
            };
            selectedItems: {
                type: PropType<VsTableItem[]>;
                default: () => VsTableItem[];
                validator: (value: VsTableItem[]) => boolean;
            };
            page: {
                type: PropType<number>;
            };
            pageSize: {
                type: PropType<number>;
                validator: (value: number, props: unknown) => boolean;
            };
            pagedItems: {
                type: PropType<VsTableItem[]>;
                default: () => never[];
            };
            totalItems: {
                type: PropType<VsTableItem[]>;
                default: () => never[];
                validator: (value: VsTableItem[]) => boolean;
            };
            search: {
                type: PropType<SearchProps>;
                default: boolean;
                validator: (value: SearchProps) => boolean;
            };
            styleSet: {
                type: PropType<string | VsTableStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            TABLE_DRAG_WRAPPER_CLASS: string;
            bodyId: ComputedRef<string>;
            colorSchemeClass: ComputedRef<string>;
            computedColorScheme: ComputedRef<
                | 'brown'
                | 'red'
                | 'orange'
                | 'amber'
                | 'yellow'
                | 'lime'
                | 'green'
                | 'emerald'
                | 'teal'
                | 'cyan'
                | 'sky'
                | 'blue'
                | 'indigo'
                | 'violet'
                | 'purple'
                | 'fuchsia'
                | 'pink'
                | 'rose'
                | 'gray'
                | 'none'
                | undefined
            >;
            componentStyleSet: ComputedRef<Partial<VsTableStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                [x: string]: boolean;
                'vs-responsive': boolean;
                'vs-primary': boolean;
            }>;
            headerSentinelRef: Readonly<ShallowRef<HTMLDivElement | null>>;
            contentTableRef: Readonly<ShallowRef<HTMLTableElement | null>>;
            scrollWrapperRef: Readonly<ShallowRef<HTMLDivElement | null>>;
            stickyScrollRef: Readonly<ShallowRef<HTMLDivElement | null>>;
            headerSlots: ComputedRef<string[]>;
            bodySlots: ComputedRef<string[]>;
            useStickyHeader: ComputedRef<boolean>;
            searchOptions: ComputedRef<{
                useRegex?: boolean;
                useCaseSensitive?: boolean;
                placeholder?: string;
            }>;
            tableColumnStyle: ComputedRef<{
                gridTemplateColumns: string;
            }>;
            stickyTableColumnStyle: ComputedRef<{
                gridTemplateColumns: string;
            }>;
            table: TableComposable;
            totalPages: ComputedRef<number>;
            clickCell: (cell: VsTableBodyCell, event: MouseEvent) => void;
            clickRow: (item: VsTableItem, index: number, event: MouseEvent) => void;
            selectRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
            expandRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
            searchRows: (searchText: string) => void;
            dragRow: (event: SortableEvent) => void;
            updateSelectedItems: (items: VsTableItem[]) => void;
            updatePage: (page: number) => void;
            updatePageSize: (pageSize: number) => void;
            expand: (index: number) => void;
            collapse: (index: number) => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        (
            | 'search'
            | 'drag'
            | 'expand-row'
            | 'select-row'
            | 'click-cell'
            | 'click-row'
            | 'paginate'
            | 'update:selectedItems'
            | 'update:page'
            | 'update:pageSize'
            | 'update:pagedItems'
            | 'update:totalItems'
        )[],
        | 'search'
        | 'drag'
        | 'expand-row'
        | 'select-row'
        | 'click-cell'
        | 'click-row'
        | 'paginate'
        | 'update:selectedItems'
        | 'update:page'
        | 'update:pageSize'
        | 'update:pagedItems'
        | 'update:totalItems',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                columns: {
                    type: PropType<VsTableColumnDef[] | string[]>;
                    default: () => never[];
                };
                items: {
                    type: PropType<VsTableItem[]>;
                    default: () => never[];
                    validator: (value: VsTableItem[]) => boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                noVirtualScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                stickyHeader: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                serverMode: {
                    type: BooleanConstructor;
                    default: boolean;
                    validator: (serverMode: boolean, props: unknown) => boolean;
                };
                draggable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                selectable: {
                    type: PropType<boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean)>;
                    default: boolean;
                };
                expandable: {
                    type: PropType<boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean)>;
                    default: boolean;
                };
                state: {
                    type: PropType<UIState | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => UIState)>;
                    default: string;
                };
                pagination: {
                    type: PropType<boolean | VsTablePaginationOptions>;
                    default: boolean;
                };
                selectedItems: {
                    type: PropType<VsTableItem[]>;
                    default: () => VsTableItem[];
                    validator: (value: VsTableItem[]) => boolean;
                };
                page: {
                    type: PropType<number>;
                };
                pageSize: {
                    type: PropType<number>;
                    validator: (value: number, props: unknown) => boolean;
                };
                pagedItems: {
                    type: PropType<VsTableItem[]>;
                    default: () => never[];
                };
                totalItems: {
                    type: PropType<VsTableItem[]>;
                    default: () => never[];
                    validator: (value: VsTableItem[]) => boolean;
                };
                search: {
                    type: PropType<SearchProps>;
                    default: boolean;
                    validator: (value: SearchProps) => boolean;
                };
                styleSet: {
                    type: PropType<string | VsTableStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onDrag?: ((...args: any[]) => any) | undefined;
                onSearch?: ((...args: any[]) => any) | undefined;
                'onExpand-row'?: ((...args: any[]) => any) | undefined;
                'onSelect-row'?: ((...args: any[]) => any) | undefined;
                'onClick-cell'?: ((...args: any[]) => any) | undefined;
                'onClick-row'?: ((...args: any[]) => any) | undefined;
                onPaginate?: ((...args: any[]) => any) | undefined;
                'onUpdate:selectedItems'?: ((...args: any[]) => any) | undefined;
                'onUpdate:page'?: ((...args: any[]) => any) | undefined;
                'onUpdate:pageSize'?: ((...args: any[]) => any) | undefined;
                'onUpdate:pagedItems'?: ((...args: any[]) => any) | undefined;
                'onUpdate:totalItems'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            search: SearchProps;
            state: UIState | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => UIState);
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            columns: string[] | VsTableColumnDef<any>[];
            primary: boolean;
            loading: boolean;
            responsive: boolean;
            items: any[];
            draggable: boolean;
            selectedItems: any[];
            pagination: boolean | VsTablePaginationOptions;
            totalItems: any[];
            noVirtualScroll: boolean;
            stickyHeader: boolean;
            serverMode: boolean;
            selectable: boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean);
            expandable: boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean);
            pagedItems: any[];
        },
        {},
        {
            VsTableHeader: DefineComponent<
                {},
                {
                    HEADER_ROW_INDEX: number;
                    headerCells: Ref<VsTableHeaderCell[], VsTableHeaderCell[]>;
                    findMatchingSlotName: (header: VsTableHeaderCell) => string;
                    showExpand: ComputedRef<boolean>;
                    clickCell: (cell: VsTableHeaderCell, event: MouseEvent) => void;
                    selectRow: (row: VsTableHeaderCell[], event: MouseEvent) => void;
                    getSortIcon: (header: VsTableHeaderCell) => Component;
                    updateSortType: (headerKey: string) => void;
                    columns: ComputedRef<VsTableColumnDef<any>[] | null>;
                    headerStyle: ComputedRef<CSSProperties | undefined>;
                    getCellStyle: (index: number) => CSSProperties;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('select-row' | 'click-cell')[],
                'select-row' | 'click-cell',
                PublicProps,
                Readonly<{}> &
                    Readonly<{
                        'onSelect-row'?: ((...args: any[]) => any) | undefined;
                        'onClick-cell'?: ((...args: any[]) => any) | undefined;
                    }>,
                {},
                {},
                {
                    VsTableDragCell: DefineComponent<
                        ExtractPropTypes<{
                            cells: {
                                type: PropType<VsTableCell[]>;
                                required: true;
                            };
                        }>,
                        {
                            TABLE_DRAG_HANDLE_CLASS: string;
                            tag: ComputedRef<VsTableTag>;
                            cellTypeClass: ComputedRef<'vs-table-td' | 'vs-table-th'>;
                            cellStyle: ComputedRef<CSSProperties | undefined>;
                            draggable: Ref<boolean | undefined, boolean | undefined> | undefined;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                cells: {
                                    type: PropType<VsTableCell[]>;
                                    required: true;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {},
                        {},
                        {
                            GripVerticalIcon: LucideIcon;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsTableExpandCell: DefineComponent<
                        ExtractPropTypes<{
                            cells: {
                                type: PropType<VsTableCell[]>;
                                default: () => never[];
                            };
                            rowIdx: {
                                type: NumberConstructor;
                                default: number;
                            };
                        }>,
                        {
                            isVsTableBodyRow: isVsTableBodyRow;
                            isExpandable: (cells: VsTableBodyCell[], rowIdx: number) => boolean;
                            isExpanded: (row: VsTableCell[]) => boolean;
                            expandRow: (cells: VsTableCell[], event: MouseEvent) => void;
                            cellStyle: ComputedRef<CSSProperties | undefined>;
                            loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                            primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                            colorScheme:
                                | ComputedRef<
                                      | 'brown'
                                      | 'red'
                                      | 'orange'
                                      | 'amber'
                                      | 'yellow'
                                      | 'lime'
                                      | 'green'
                                      | 'emerald'
                                      | 'teal'
                                      | 'cyan'
                                      | 'sky'
                                      | 'blue'
                                      | 'indigo'
                                      | 'violet'
                                      | 'purple'
                                      | 'fuchsia'
                                      | 'pink'
                                      | 'rose'
                                      | 'gray'
                                      | 'none'
                                      | undefined
                                  >
                                | undefined;
                            buttonSize: ComputedRef<'xs' | 'sm' | 'md' | 'lg' | 'xl'>;
                            expandButtonStyleSet: ComputedRef<{
                                $content: {
                                    padding: string;
                                };
                                border: string;
                                width: string;
                                height: string;
                                backgroundColor: string;
                                color: string;
                            }>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        'expand-row'[],
                        'expand-row',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                cells: {
                                    type: PropType<VsTableCell[]>;
                                    default: () => never[];
                                };
                                rowIdx: {
                                    type: NumberConstructor;
                                    default: number;
                                };
                            }>
                        > &
                            Readonly<{
                                'onExpand-row'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            cells: VsTableCell<any>[];
                            rowIdx: number;
                        },
                        {},
                        {
                            VsButton: DefineComponent<
                                ExtractPropTypes<{
                                    circle: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    ghost: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    loading: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    outline: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    primary: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    responsive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    type: {
                                        type: PropType<'button' | 'submit' | 'reset'>;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsButtonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    colorSchemeClass: ComputedRef<string>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                    classObj: ComputedRef<{
                                        [x: string]: boolean;
                                        'vs-focus-visible': boolean;
                                        'vs-circle': boolean;
                                        'vs-disabled': boolean;
                                        'vs-ghost': boolean;
                                        'vs-loading-state': boolean;
                                        'vs-outline': boolean;
                                        'vs-primary': boolean;
                                        'vs-responsive': boolean;
                                    }>;
                                    buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                    componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        circle: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        ghost: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        loading: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        outline: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        primary: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        responsive: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        type: {
                                            type: PropType<'button' | 'submit' | 'reset'>;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsButtonStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    circle: boolean;
                                    disabled: boolean;
                                    type: 'button' | 'reset' | 'submit';
                                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                    outline: boolean;
                                    primary: boolean;
                                    ghost: boolean;
                                    loading: boolean;
                                    responsive: boolean;
                                },
                                {},
                                {
                                    VsLoading: DefineComponent<
                                        ExtractPropTypes<{
                                            width: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            styleSet: {
                                                type: PropType<string | VsLoadingStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>,
                                        {
                                            colorSchemeClass: ComputedRef<string>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                width: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                height: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsLoadingStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {},
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            ChevronDownIcon: LucideIcon;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsTableCheckboxCell: DefineComponent<
                        ExtractPropTypes<{
                            cells: {
                                type: PropType<VsTableCell[]>;
                                default: () => never[];
                            };
                            rowIdx: {
                                type: NumberConstructor;
                                required: true;
                            };
                        }>,
                        {
                            HEADER_ROW_INDEX: number;
                            isBodyRow: isVsTableBodyRow;
                            getRowItem: getRowItem;
                            isSelected: (row: VsTableCell[]) => boolean;
                            isRowSelectable: (row: VsTableCell[], rowIdx: number) => boolean;
                            selectRow: (row: VsTableCell[], event: MouseEvent) => void;
                            anySelectable: ComputedRef<boolean>;
                            selectedItems: Ref<any[], any[]>;
                            selectedAll: ComputedRef<boolean>;
                            selectedPartial: ComputedRef<boolean>;
                            cellStyle: ComputedRef<CSSProperties | undefined>;
                            loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                            primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                            headerCheckboxStyle: ComputedRef<VsCheckboxStyleSet>;
                            colorScheme:
                                | ComputedRef<
                                      | 'brown'
                                      | 'red'
                                      | 'orange'
                                      | 'amber'
                                      | 'yellow'
                                      | 'lime'
                                      | 'green'
                                      | 'emerald'
                                      | 'teal'
                                      | 'cyan'
                                      | 'sky'
                                      | 'blue'
                                      | 'indigo'
                                      | 'violet'
                                      | 'purple'
                                      | 'fuchsia'
                                      | 'pink'
                                      | 'rose'
                                      | 'gray'
                                      | 'none'
                                      | undefined
                                  >
                                | undefined;
                            size: Ref<'xs' | 'sm' | 'md' | 'lg' | 'xl', 'xs' | 'sm' | 'md' | 'lg' | 'xl'> | undefined;
                            columns: ComputedRef<VsTableColumnDef<any>[] | null>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        'select-row'[],
                        'select-row',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                cells: {
                                    type: PropType<VsTableCell[]>;
                                    default: () => never[];
                                };
                                rowIdx: {
                                    type: NumberConstructor;
                                    required: true;
                                };
                            }>
                        > &
                            Readonly<{
                                'onSelect-row'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            cells: VsTableCell<any>[];
                        },
                        {},
                        {
                            VsCheckbox: DefineComponent<
                                ExtractPropTypes<{
                                    beforeChange: {
                                        type: PropType<
                                            (from: any, to: any, optionValue: any) => Promise<boolean> | null
                                        >;
                                        default: null;
                                    };
                                    checked: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    checkLabel: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    indeterminate: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    multiple: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    trueValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    falseValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    modelValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    messages: {
                                        type: PropType<Message<any>[]>;
                                        default: () => Message<any>[];
                                    };
                                    name: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noDefaultRules: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    readonly: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    rules: {
                                        type: PropType<Rule<any>[]>;
                                        default: () => Rule<any>[];
                                    };
                                    state: {
                                        type: PropType<UIState>;
                                        default: UIState;
                                    };
                                    changed: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    valid: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsCheckboxStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                                    colorSchemeClass: ComputedRef<string>;
                                    componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                    classObj: ComputedRef<{
                                        'vs-checked': boolean;
                                        'vs-disabled': boolean;
                                        'vs-focus-visible': boolean;
                                        'vs-indeterminate': boolean;
                                        'vs-readonly': boolean;
                                    }>;
                                    sizeClass: ComputedRef<string>;
                                    stateBoxClasses: ComputedRef<{}>;
                                    computedId: ComputedRef<string>;
                                    computedDisabled: ComputedRef<boolean>;
                                    computedReadonly: ComputedRef<boolean>;
                                    computedMessages: ComputedRef<StateMessage<UIState>[]>;
                                    computedState: ComputedRef<UIState>;
                                    convertToString: (value: any) => string;
                                    inputValue: Ref<any, any>;
                                    isChecked: ComputedRef<boolean>;
                                    shake: Ref<boolean, boolean>;
                                    toggle: (e: MouseEvent) => Promise<void>;
                                    onFocus: (e: FocusEvent) => void;
                                    onBlur: (e: FocusEvent) => void;
                                    validate: () => boolean;
                                    clear: () => void;
                                    reset: () => void;
                                    focus: () => void;
                                    blur: () => void;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                (
                                    | 'blur'
                                    | 'change'
                                    | 'focus'
                                    | 'toggle'
                                    | 'clear'
                                    | 'update:modelValue'
                                    | 'update:changed'
                                    | 'update:valid'
                                )[],
                                | 'blur'
                                | 'change'
                                | 'focus'
                                | 'toggle'
                                | 'clear'
                                | 'update:modelValue'
                                | 'update:changed'
                                | 'update:valid',
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        beforeChange: {
                                            type: PropType<
                                                (from: any, to: any, optionValue: any) => Promise<boolean> | null
                                            >;
                                            default: null;
                                        };
                                        checked: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        checkLabel: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        indeterminate: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        multiple: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        trueValue: {
                                            type: null;
                                            default: boolean;
                                        };
                                        falseValue: {
                                            type: null;
                                            default: boolean;
                                        };
                                        modelValue: {
                                            type: null;
                                            default: boolean;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        label: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        messages: {
                                            type: PropType<Message<any>[]>;
                                            default: () => Message<any>[];
                                        };
                                        name: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noDefaultRules: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        readonly: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        rules: {
                                            type: PropType<Rule<any>[]>;
                                            default: () => Rule<any>[];
                                        };
                                        state: {
                                            type: PropType<UIState>;
                                            default: UIState;
                                        };
                                        changed: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        valid: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        hidden: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        id: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noLabel: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        noMessages: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        required: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsCheckboxStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{
                                        onFocus?: ((...args: any[]) => any) | undefined;
                                        onBlur?: ((...args: any[]) => any) | undefined;
                                        onChange?: ((...args: any[]) => any) | undefined;
                                        onToggle?: ((...args: any[]) => any) | undefined;
                                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                        onClear?: ((...args: any[]) => any) | undefined;
                                        'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                        'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                                    }>,
                                {
                                    label: string;
                                    messages: Message<any>[];
                                    name: string;
                                    noDefaultRules: boolean;
                                    readonly: boolean;
                                    rules: Rule<any>[];
                                    state: UIState;
                                    changed: boolean;
                                    valid: boolean;
                                    disabled: boolean;
                                    hidden: boolean;
                                    id: string;
                                    noLabel: boolean;
                                    noMessages: boolean;
                                    required: boolean;
                                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                    multiple: boolean;
                                    modelValue: any;
                                    beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                                    checked: boolean;
                                    checkLabel: string;
                                    indeterminate: boolean;
                                    trueValue: any;
                                    falseValue: any;
                                },
                                {},
                                {
                                    VsInputWrapper: DefineComponent<
                                        ExtractPropTypes<{
                                            groupLabel: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            messages: {
                                                type: PropType<StateMessage<UIState>[]>;
                                                default: () => never[];
                                            };
                                            shake: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsInputWrapperStyleSet>;
                                            };
                                            disabled: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            hidden: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            id: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            label: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noLabel: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            noMessages: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            required: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>,
                                        {
                                            needToShake: Ref<boolean, boolean>;
                                            componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                groupLabel: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                messages: {
                                                    type: PropType<StateMessage<UIState>[]>;
                                                    default: () => never[];
                                                };
                                                shake: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsInputWrapperStyleSet>;
                                                };
                                                disabled: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                hidden: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                id: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                label: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                noLabel: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                noMessages: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                required: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            label: string;
                                            messages: StateMessage<UIState>[];
                                            disabled: boolean;
                                            hidden: boolean;
                                            id: string;
                                            noLabel: boolean;
                                            noMessages: boolean;
                                            required: boolean;
                                            groupLabel: boolean;
                                            shake: boolean;
                                        },
                                        {},
                                        {
                                            VsResponsive: DefineComponent<
                                                ExtractPropTypes<{
                                                    tag: {
                                                        type: StringConstructor;
                                                        default: string;
                                                    };
                                                    width: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                    grid: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                }>,
                                                {
                                                    responsiveClasses: ComputedRef<string[]>;
                                                    responsiveStyles: ComputedRef<Record<string, string>>;
                                                },
                                                {},
                                                {},
                                                {},
                                                ComponentOptionsMixin,
                                                ComponentOptionsMixin,
                                                {},
                                                string,
                                                PublicProps,
                                                Readonly<
                                                    ExtractPropTypes<{
                                                        tag: {
                                                            type: StringConstructor;
                                                            default: string;
                                                        };
                                                        width: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                        grid: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                    }>
                                                > &
                                                    Readonly<{}>,
                                                {
                                                    tag: string;
                                                },
                                                {},
                                                {},
                                                {},
                                                string,
                                                ComponentProvideOptions,
                                                true,
                                                {},
                                                any
                                            >;
                                            VsMessage: DefineComponent<
                                                ExtractPropTypes<{
                                                    state: {
                                                        type: PropType<UIState>;
                                                        default: string;
                                                    };
                                                    text: {
                                                        type: StringConstructor;
                                                        default: string;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsMessageStyleSet>;
                                                    };
                                                }>,
                                                {
                                                    colorClass: ComputedRef<
                                                        | 'vs-cs-blue'
                                                        | 'vs-cs-green'
                                                        | 'vs-cs-amber'
                                                        | 'vs-cs-red'
                                                        | 'vs-cs-default'
                                                    >;
                                                    icon: ComputedRef<Component>;
                                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                                },
                                                {},
                                                {},
                                                {},
                                                ComponentOptionsMixin,
                                                ComponentOptionsMixin,
                                                {},
                                                string,
                                                PublicProps,
                                                Readonly<
                                                    ExtractPropTypes<{
                                                        state: {
                                                            type: PropType<UIState>;
                                                            default: string;
                                                        };
                                                        text: {
                                                            type: StringConstructor;
                                                            default: string;
                                                        };
                                                        styleSet: {
                                                            type: PropType<string | VsMessageStyleSet>;
                                                        };
                                                    }>
                                                > &
                                                    Readonly<{}>,
                                                {
                                                    text: string;
                                                    state: UIState;
                                                },
                                                {},
                                                {},
                                                {},
                                                string,
                                                ComponentProvideOptions,
                                                true,
                                                {},
                                                any
                                            >;
                                        },
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsTableBody: DefineComponent<
                ExtractPropTypes<{
                    id: {
                        type: StringConstructor;
                        default: string;
                    };
                }>,
                {
                    DEFAULT_SORTABLE_OPTIONS: Partial<Options>;
                    TABLE_DRAG_WRAPPER_CLASS: string;
                    bodySlots: ComputedRef<string[]>;
                    colorScheme:
                        | ComputedRef<
                              | 'brown'
                              | 'red'
                              | 'orange'
                              | 'amber'
                              | 'yellow'
                              | 'lime'
                              | 'green'
                              | 'emerald'
                              | 'teal'
                              | 'cyan'
                              | 'sky'
                              | 'blue'
                              | 'indigo'
                              | 'violet'
                              | 'purple'
                              | 'fuchsia'
                              | 'pink'
                              | 'rose'
                              | 'gray'
                              | 'none'
                              | undefined
                          >
                        | undefined;
                    displayedBodyCells: WritableComputedRef<VsTableBodyCell<any>[][], VsTableBodyCell<any>[][]>;
                    loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                    clickCell: (cell: VsTableBodyCell, event: MouseEvent) => void;
                    clickRow: (item: VsTableBodyCell['item'], index: number, event: MouseEvent) => void;
                    getRowItem: getRowItem;
                    getRowId: getRowId;
                    selectRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
                    expandRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
                    handleDragUpdate: (event: SortableEvent) => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('drag' | 'expand-row' | 'select-row' | 'click-cell' | 'click-row')[],
                'drag' | 'expand-row' | 'select-row' | 'click-cell' | 'click-row',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        id: {
                            type: StringConstructor;
                            default: string;
                        };
                    }>
                > &
                    Readonly<{
                        onDrag?: ((...args: any[]) => any) | undefined;
                        'onExpand-row'?: ((...args: any[]) => any) | undefined;
                        'onSelect-row'?: ((...args: any[]) => any) | undefined;
                        'onClick-cell'?: ((...args: any[]) => any) | undefined;
                        'onClick-row'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    id: string;
                },
                {},
                {
                    VsLoading: DefineComponent<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                width: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                height: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                styleSet: {
                                    type: PropType<string | VsLoadingStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {},
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsTableBodyRow: DefineComponent<
                        ExtractPropTypes<{
                            cells: {
                                type: PropType<VsTableBodyCell[]>;
                                required: true;
                            };
                            rowIdx: {
                                type: NumberConstructor;
                                required: true;
                            };
                        }>,
                        {
                            anyExpandable: ComputedRef<boolean>;
                            colorScheme:
                                | ComputedRef<
                                      | 'brown'
                                      | 'red'
                                      | 'orange'
                                      | 'amber'
                                      | 'yellow'
                                      | 'lime'
                                      | 'green'
                                      | 'emerald'
                                      | 'teal'
                                      | 'cyan'
                                      | 'sky'
                                      | 'blue'
                                      | 'indigo'
                                      | 'violet'
                                      | 'purple'
                                      | 'fuchsia'
                                      | 'pink'
                                      | 'rose'
                                      | 'gray'
                                      | 'none'
                                      | undefined
                                  >
                                | undefined;
                            loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                            classObj: ComputedRef<{
                                'vs-selected': boolean;
                            }>;
                            rowStyle: ComputedRef<CSSProperties | undefined>;
                            showExpand: ComputedRef<boolean>;
                            getCellStyle: (index: number) => CSSProperties;
                            stateClasses: ComputedRef<
                                | {
                                      'vs-stated'?: undefined;
                                  }
                                | {
                                      [x: string]: true;
                                      'vs-stated': true;
                                  }
                            >;
                            clickCell: (cell: VsTableBodyCell, event: MouseEvent) => void;
                            findMatchingSlotName: (cell: VsTableBodyCell) => string;
                            selectRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
                            expandRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
                            getHeaderLabel: (colIdx: number, fallback: string) => string;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        ('expand-row' | 'select-row' | 'click-cell' | 'click-row')[],
                        'expand-row' | 'select-row' | 'click-cell' | 'click-row',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                cells: {
                                    type: PropType<VsTableBodyCell[]>;
                                    required: true;
                                };
                                rowIdx: {
                                    type: NumberConstructor;
                                    required: true;
                                };
                            }>
                        > &
                            Readonly<{
                                'onExpand-row'?: ((...args: any[]) => any) | undefined;
                                'onSelect-row'?: ((...args: any[]) => any) | undefined;
                                'onClick-cell'?: ((...args: any[]) => any) | undefined;
                                'onClick-row'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {},
                        {},
                        {
                            VsSkeleton: DefineComponent<
                                ExtractPropTypes<{
                                    styleSet: {
                                        type: PropType<string | VsSkeletonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    colorSchemeClass: ComputedRef<string>;
                                    componentStyleSet: ComputedRef<Partial<VsSkeletonStyleSet>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        styleSet: {
                                            type: PropType<string | VsSkeletonStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {},
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsTableDragCell: DefineComponent<
                                ExtractPropTypes<{
                                    cells: {
                                        type: PropType<VsTableCell[]>;
                                        required: true;
                                    };
                                }>,
                                {
                                    TABLE_DRAG_HANDLE_CLASS: string;
                                    tag: ComputedRef<VsTableTag>;
                                    cellTypeClass: ComputedRef<'vs-table-td' | 'vs-table-th'>;
                                    cellStyle: ComputedRef<CSSProperties | undefined>;
                                    draggable: Ref<boolean | undefined, boolean | undefined> | undefined;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        cells: {
                                            type: PropType<VsTableCell[]>;
                                            required: true;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {},
                                {},
                                {
                                    GripVerticalIcon: LucideIcon;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsTableExpandCell: DefineComponent<
                                ExtractPropTypes<{
                                    cells: {
                                        type: PropType<VsTableCell[]>;
                                        default: () => never[];
                                    };
                                    rowIdx: {
                                        type: NumberConstructor;
                                        default: number;
                                    };
                                }>,
                                {
                                    isVsTableBodyRow: isVsTableBodyRow;
                                    isExpandable: (cells: VsTableBodyCell[], rowIdx: number) => boolean;
                                    isExpanded: (row: VsTableCell[]) => boolean;
                                    expandRow: (cells: VsTableCell[], event: MouseEvent) => void;
                                    cellStyle: ComputedRef<CSSProperties | undefined>;
                                    loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                                    primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                                    colorScheme:
                                        | ComputedRef<
                                              | 'brown'
                                              | 'red'
                                              | 'orange'
                                              | 'amber'
                                              | 'yellow'
                                              | 'lime'
                                              | 'green'
                                              | 'emerald'
                                              | 'teal'
                                              | 'cyan'
                                              | 'sky'
                                              | 'blue'
                                              | 'indigo'
                                              | 'violet'
                                              | 'purple'
                                              | 'fuchsia'
                                              | 'pink'
                                              | 'rose'
                                              | 'gray'
                                              | 'none'
                                              | undefined
                                          >
                                        | undefined;
                                    buttonSize: ComputedRef<'xs' | 'sm' | 'md' | 'lg' | 'xl'>;
                                    expandButtonStyleSet: ComputedRef<{
                                        $content: {
                                            padding: string;
                                        };
                                        border: string;
                                        width: string;
                                        height: string;
                                        backgroundColor: string;
                                        color: string;
                                    }>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                'expand-row'[],
                                'expand-row',
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        cells: {
                                            type: PropType<VsTableCell[]>;
                                            default: () => never[];
                                        };
                                        rowIdx: {
                                            type: NumberConstructor;
                                            default: number;
                                        };
                                    }>
                                > &
                                    Readonly<{
                                        'onExpand-row'?: ((...args: any[]) => any) | undefined;
                                    }>,
                                {
                                    cells: VsTableCell<any>[];
                                    rowIdx: number;
                                },
                                {},
                                {
                                    VsButton: DefineComponent<
                                        ExtractPropTypes<{
                                            circle: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            disabled: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            ghost: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            loading: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            outline: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            primary: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            responsive: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            type: {
                                                type: PropType<'button' | 'submit' | 'reset'>;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsButtonStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>,
                                        {
                                            colorSchemeClass: ComputedRef<string>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                            classObj: ComputedRef<{
                                                [x: string]: boolean;
                                                'vs-focus-visible': boolean;
                                                'vs-circle': boolean;
                                                'vs-disabled': boolean;
                                                'vs-ghost': boolean;
                                                'vs-loading-state': boolean;
                                                'vs-outline': boolean;
                                                'vs-primary': boolean;
                                                'vs-responsive': boolean;
                                            }>;
                                            buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                            componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                circle: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                disabled: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                ghost: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                loading: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                outline: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                primary: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                responsive: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                size: {
                                                    type: PropType<Size>;
                                                    default: string;
                                                };
                                                type: {
                                                    type: PropType<'button' | 'submit' | 'reset'>;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsButtonStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            circle: boolean;
                                            disabled: boolean;
                                            type: 'button' | 'reset' | 'submit';
                                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                            outline: boolean;
                                            primary: boolean;
                                            ghost: boolean;
                                            loading: boolean;
                                            responsive: boolean;
                                        },
                                        {},
                                        {
                                            VsLoading: DefineComponent<
                                                ExtractPropTypes<{
                                                    width: {
                                                        type: (StringConstructor | NumberConstructor)[];
                                                    };
                                                    height: {
                                                        type: (StringConstructor | NumberConstructor)[];
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsLoadingStyleSet>;
                                                    };
                                                    colorScheme: {
                                                        type: PropType<ColorScheme>;
                                                    };
                                                }>,
                                                {
                                                    colorSchemeClass: ComputedRef<string>;
                                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                                },
                                                {},
                                                {},
                                                {},
                                                ComponentOptionsMixin,
                                                ComponentOptionsMixin,
                                                {},
                                                string,
                                                PublicProps,
                                                Readonly<
                                                    ExtractPropTypes<{
                                                        width: {
                                                            type: (StringConstructor | NumberConstructor)[];
                                                        };
                                                        height: {
                                                            type: (StringConstructor | NumberConstructor)[];
                                                        };
                                                        styleSet: {
                                                            type: PropType<string | VsLoadingStyleSet>;
                                                        };
                                                        colorScheme: {
                                                            type: PropType<ColorScheme>;
                                                        };
                                                    }>
                                                > &
                                                    Readonly<{}>,
                                                {},
                                                {},
                                                {},
                                                {},
                                                string,
                                                ComponentProvideOptions,
                                                true,
                                                {},
                                                any
                                            >;
                                        },
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                    ChevronDownIcon: LucideIcon;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsTableExpandedPanel: DefineComponent<
                                ExtractPropTypes<{
                                    cells: {
                                        type: PropType<VsTableBodyCell[]>;
                                        required: true;
                                    };
                                    rowIdx: {
                                        type: NumberConstructor;
                                        required: true;
                                    };
                                }>,
                                {
                                    isExpanded: (row: VsTableCell[]) => boolean;
                                    size:
                                        | Ref<
                                              'xs' | 'sm' | 'md' | 'lg' | 'xl' | undefined,
                                              'xs' | 'sm' | 'md' | 'lg' | 'xl' | undefined
                                          >
                                        | undefined;
                                    getRowItem: getRowItem;
                                    expandableStyleSet: ComputedRef<VsExpandableStyleSet>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        cells: {
                                            type: PropType<VsTableBodyCell[]>;
                                            required: true;
                                        };
                                        rowIdx: {
                                            type: NumberConstructor;
                                            required: true;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {},
                                {},
                                {
                                    VsExpandable: DefineComponent<
                                        ExtractPropTypes<{
                                            open: {
                                                type: BooleanConstructor;
                                                required: true;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsExpandableStyleSet>;
                                            };
                                        }>,
                                        {
                                            sizeClass: ComputedRef<string>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                            beforeEnter: (el: Element) => void;
                                            enter: (el: Element, done: () => void) => void;
                                            beforeLeave: (el: Element) => void;
                                            leave: (el: Element, done: () => void) => void;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                open: {
                                                    type: BooleanConstructor;
                                                    required: true;
                                                    default: boolean;
                                                };
                                                size: {
                                                    type: PropType<Size>;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsExpandableStyleSet>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                        },
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsTableCheckboxCell: DefineComponent<
                                ExtractPropTypes<{
                                    cells: {
                                        type: PropType<VsTableCell[]>;
                                        default: () => never[];
                                    };
                                    rowIdx: {
                                        type: NumberConstructor;
                                        required: true;
                                    };
                                }>,
                                {
                                    HEADER_ROW_INDEX: number;
                                    isBodyRow: isVsTableBodyRow;
                                    getRowItem: getRowItem;
                                    isSelected: (row: VsTableCell[]) => boolean;
                                    isRowSelectable: (row: VsTableCell[], rowIdx: number) => boolean;
                                    selectRow: (row: VsTableCell[], event: MouseEvent) => void;
                                    anySelectable: ComputedRef<boolean>;
                                    selectedItems: Ref<any[], any[]>;
                                    selectedAll: ComputedRef<boolean>;
                                    selectedPartial: ComputedRef<boolean>;
                                    cellStyle: ComputedRef<CSSProperties | undefined>;
                                    loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                                    primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                                    headerCheckboxStyle: ComputedRef<VsCheckboxStyleSet>;
                                    colorScheme:
                                        | ComputedRef<
                                              | 'brown'
                                              | 'red'
                                              | 'orange'
                                              | 'amber'
                                              | 'yellow'
                                              | 'lime'
                                              | 'green'
                                              | 'emerald'
                                              | 'teal'
                                              | 'cyan'
                                              | 'sky'
                                              | 'blue'
                                              | 'indigo'
                                              | 'violet'
                                              | 'purple'
                                              | 'fuchsia'
                                              | 'pink'
                                              | 'rose'
                                              | 'gray'
                                              | 'none'
                                              | undefined
                                          >
                                        | undefined;
                                    size:
                                        | Ref<'xs' | 'sm' | 'md' | 'lg' | 'xl', 'xs' | 'sm' | 'md' | 'lg' | 'xl'>
                                        | undefined;
                                    columns: ComputedRef<VsTableColumnDef<any>[] | null>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                'select-row'[],
                                'select-row',
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        cells: {
                                            type: PropType<VsTableCell[]>;
                                            default: () => never[];
                                        };
                                        rowIdx: {
                                            type: NumberConstructor;
                                            required: true;
                                        };
                                    }>
                                > &
                                    Readonly<{
                                        'onSelect-row'?: ((...args: any[]) => any) | undefined;
                                    }>,
                                {
                                    cells: VsTableCell<any>[];
                                },
                                {},
                                {
                                    VsCheckbox: DefineComponent<
                                        ExtractPropTypes<{
                                            beforeChange: {
                                                type: PropType<
                                                    (from: any, to: any, optionValue: any) => Promise<boolean> | null
                                                >;
                                                default: null;
                                            };
                                            checked: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            checkLabel: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            indeterminate: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            multiple: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            trueValue: {
                                                type: null;
                                                default: boolean;
                                            };
                                            falseValue: {
                                                type: null;
                                                default: boolean;
                                            };
                                            modelValue: {
                                                type: null;
                                                default: boolean;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            label: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            messages: {
                                                type: PropType<Message<any>[]>;
                                                default: () => Message<any>[];
                                            };
                                            name: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noDefaultRules: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            readonly: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            rules: {
                                                type: PropType<Rule<any>[]>;
                                                default: () => Rule<any>[];
                                            };
                                            state: {
                                                type: PropType<UIState>;
                                                default: UIState;
                                            };
                                            changed: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            valid: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            disabled: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            hidden: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            id: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noLabel: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            noMessages: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            required: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsCheckboxStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>,
                                        {
                                            checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                                            colorSchemeClass: ComputedRef<string>;
                                            componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                            classObj: ComputedRef<{
                                                'vs-checked': boolean;
                                                'vs-disabled': boolean;
                                                'vs-focus-visible': boolean;
                                                'vs-indeterminate': boolean;
                                                'vs-readonly': boolean;
                                            }>;
                                            sizeClass: ComputedRef<string>;
                                            stateBoxClasses: ComputedRef<{}>;
                                            computedId: ComputedRef<string>;
                                            computedDisabled: ComputedRef<boolean>;
                                            computedReadonly: ComputedRef<boolean>;
                                            computedMessages: ComputedRef<StateMessage<UIState>[]>;
                                            computedState: ComputedRef<UIState>;
                                            convertToString: (value: any) => string;
                                            inputValue: Ref<any, any>;
                                            isChecked: ComputedRef<boolean>;
                                            shake: Ref<boolean, boolean>;
                                            toggle: (e: MouseEvent) => Promise<void>;
                                            onFocus: (e: FocusEvent) => void;
                                            onBlur: (e: FocusEvent) => void;
                                            validate: () => boolean;
                                            clear: () => void;
                                            reset: () => void;
                                            focus: () => void;
                                            blur: () => void;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        (
                                            | 'blur'
                                            | 'change'
                                            | 'focus'
                                            | 'toggle'
                                            | 'clear'
                                            | 'update:modelValue'
                                            | 'update:changed'
                                            | 'update:valid'
                                        )[],
                                        | 'blur'
                                        | 'change'
                                        | 'focus'
                                        | 'toggle'
                                        | 'clear'
                                        | 'update:modelValue'
                                        | 'update:changed'
                                        | 'update:valid',
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                beforeChange: {
                                                    type: PropType<
                                                        (
                                                            from: any,
                                                            to: any,
                                                            optionValue: any,
                                                        ) => Promise<boolean> | null
                                                    >;
                                                    default: null;
                                                };
                                                checked: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                checkLabel: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                indeterminate: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                multiple: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                size: {
                                                    type: PropType<Size>;
                                                    default: string;
                                                };
                                                trueValue: {
                                                    type: null;
                                                    default: boolean;
                                                };
                                                falseValue: {
                                                    type: null;
                                                    default: boolean;
                                                };
                                                modelValue: {
                                                    type: null;
                                                    default: boolean;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                label: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                messages: {
                                                    type: PropType<Message<any>[]>;
                                                    default: () => Message<any>[];
                                                };
                                                name: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                noDefaultRules: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                readonly: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                rules: {
                                                    type: PropType<Rule<any>[]>;
                                                    default: () => Rule<any>[];
                                                };
                                                state: {
                                                    type: PropType<UIState>;
                                                    default: UIState;
                                                };
                                                changed: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                valid: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                disabled: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                hidden: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                id: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                noLabel: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                noMessages: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                required: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsCheckboxStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>
                                        > &
                                            Readonly<{
                                                onFocus?: ((...args: any[]) => any) | undefined;
                                                onBlur?: ((...args: any[]) => any) | undefined;
                                                onChange?: ((...args: any[]) => any) | undefined;
                                                onToggle?: ((...args: any[]) => any) | undefined;
                                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                                onClear?: ((...args: any[]) => any) | undefined;
                                                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                                            }>,
                                        {
                                            label: string;
                                            messages: Message<any>[];
                                            name: string;
                                            noDefaultRules: boolean;
                                            readonly: boolean;
                                            rules: Rule<any>[];
                                            state: UIState;
                                            changed: boolean;
                                            valid: boolean;
                                            disabled: boolean;
                                            hidden: boolean;
                                            id: string;
                                            noLabel: boolean;
                                            noMessages: boolean;
                                            required: boolean;
                                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                            multiple: boolean;
                                            modelValue: any;
                                            beforeChange: (
                                                from: any,
                                                to: any,
                                                optionValue: any,
                                            ) => Promise<boolean> | null;
                                            checked: boolean;
                                            checkLabel: string;
                                            indeterminate: boolean;
                                            trueValue: any;
                                            falseValue: any;
                                        },
                                        {},
                                        {
                                            VsInputWrapper: DefineComponent<
                                                ExtractPropTypes<{
                                                    groupLabel: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    messages: {
                                                        type: PropType<StateMessage<UIState>[]>;
                                                        default: () => never[];
                                                    };
                                                    shake: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsInputWrapperStyleSet>;
                                                    };
                                                    disabled: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    hidden: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    id: {
                                                        type: typeof String;
                                                        default: string;
                                                    };
                                                    label: {
                                                        type: typeof String;
                                                        default: string;
                                                    };
                                                    noLabel: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    noMessages: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    required: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    width: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                    grid: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                }>,
                                                {
                                                    needToShake: Ref<boolean, boolean>;
                                                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                                },
                                                {},
                                                {},
                                                {},
                                                ComponentOptionsMixin,
                                                ComponentOptionsMixin,
                                                {},
                                                string,
                                                PublicProps,
                                                Readonly<
                                                    ExtractPropTypes<{
                                                        groupLabel: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        messages: {
                                                            type: PropType<StateMessage<UIState>[]>;
                                                            default: () => never[];
                                                        };
                                                        shake: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        styleSet: {
                                                            type: PropType<string | VsInputWrapperStyleSet>;
                                                        };
                                                        disabled: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        hidden: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        id: {
                                                            type: typeof String;
                                                            default: string;
                                                        };
                                                        label: {
                                                            type: typeof String;
                                                            default: string;
                                                        };
                                                        noLabel: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        noMessages: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        required: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        width: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                        grid: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                    }>
                                                > &
                                                    Readonly<{}>,
                                                {
                                                    label: string;
                                                    messages: StateMessage<UIState>[];
                                                    disabled: boolean;
                                                    hidden: boolean;
                                                    id: string;
                                                    noLabel: boolean;
                                                    noMessages: boolean;
                                                    required: boolean;
                                                    groupLabel: boolean;
                                                    shake: boolean;
                                                },
                                                {},
                                                {
                                                    VsResponsive: DefineComponent<
                                                        ExtractPropTypes<{
                                                            tag: {
                                                                type: StringConstructor;
                                                                default: string;
                                                            };
                                                            width: {
                                                                type: PropType<string | number | Breakpoints>;
                                                            };
                                                            grid: {
                                                                type: PropType<string | number | Breakpoints>;
                                                            };
                                                        }>,
                                                        {
                                                            responsiveClasses: ComputedRef<string[]>;
                                                            responsiveStyles: ComputedRef<Record<string, string>>;
                                                        },
                                                        {},
                                                        {},
                                                        {},
                                                        ComponentOptionsMixin,
                                                        ComponentOptionsMixin,
                                                        {},
                                                        string,
                                                        PublicProps,
                                                        Readonly<
                                                            ExtractPropTypes<{
                                                                tag: {
                                                                    type: StringConstructor;
                                                                    default: string;
                                                                };
                                                                width: {
                                                                    type: PropType<string | number | Breakpoints>;
                                                                };
                                                                grid: {
                                                                    type: PropType<string | number | Breakpoints>;
                                                                };
                                                            }>
                                                        > &
                                                            Readonly<{}>,
                                                        {
                                                            tag: string;
                                                        },
                                                        {},
                                                        {},
                                                        {},
                                                        string,
                                                        ComponentProvideOptions,
                                                        true,
                                                        {},
                                                        any
                                                    >;
                                                    VsMessage: DefineComponent<
                                                        ExtractPropTypes<{
                                                            state: {
                                                                type: PropType<UIState>;
                                                                default: string;
                                                            };
                                                            text: {
                                                                type: StringConstructor;
                                                                default: string;
                                                            };
                                                            styleSet: {
                                                                type: PropType<string | VsMessageStyleSet>;
                                                            };
                                                        }>,
                                                        {
                                                            colorClass: ComputedRef<
                                                                | 'vs-cs-blue'
                                                                | 'vs-cs-green'
                                                                | 'vs-cs-amber'
                                                                | 'vs-cs-red'
                                                                | 'vs-cs-default'
                                                            >;
                                                            icon: ComputedRef<Component>;
                                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                                        },
                                                        {},
                                                        {},
                                                        {},
                                                        ComponentOptionsMixin,
                                                        ComponentOptionsMixin,
                                                        {},
                                                        string,
                                                        PublicProps,
                                                        Readonly<
                                                            ExtractPropTypes<{
                                                                state: {
                                                                    type: PropType<UIState>;
                                                                    default: string;
                                                                };
                                                                text: {
                                                                    type: StringConstructor;
                                                                    default: string;
                                                                };
                                                                styleSet: {
                                                                    type: PropType<string | VsMessageStyleSet>;
                                                                };
                                                            }>
                                                        > &
                                                            Readonly<{}>,
                                                        {
                                                            text: string;
                                                            state: UIState;
                                                        },
                                                        {},
                                                        {},
                                                        {},
                                                        string,
                                                        ComponentProvideOptions,
                                                        true,
                                                        {},
                                                        any
                                                    >;
                                                },
                                                {},
                                                string,
                                                ComponentProvideOptions,
                                                true,
                                                {},
                                                any
                                            >;
                                        },
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    BanIcon: LucideIcon;
                    draggable: 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;
                        },
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        any[],
                        any,
                        VNodeProps & AllowedComponentProps & 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,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsSearchInput: DefineComponent<
                ExtractPropTypes<{
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: string;
                    };
                    readonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    useCaseSensitive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    useRegex: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: string;
                    };
                    caseSensitive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    regex: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    styleSet: {
                        type: PropType<string | VsSearchInputStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    inputRef: Readonly<ShallowRef<VsInputRef | null>>;
                    searchText: Ref<string, string>;
                    isCaseSensitiveOn: Ref<boolean, boolean>;
                    isRegexOn: Ref<boolean, boolean>;
                    computedColorScheme: ComputedRef<
                        | 'brown'
                        | 'red'
                        | 'orange'
                        | 'amber'
                        | 'yellow'
                        | 'lime'
                        | 'green'
                        | 'emerald'
                        | 'teal'
                        | 'cyan'
                        | 'sky'
                        | 'blue'
                        | 'indigo'
                        | 'violet'
                        | 'purple'
                        | 'fuchsia'
                        | 'pink'
                        | 'rose'
                        | 'gray'
                        | 'none'
                        | undefined
                    >;
                    componentStyleSet: ComputedRef<Partial<VsSearchInputStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    onInputChange: (value: string | number | null) => void;
                    match: (text: string) => boolean;
                    focus: () => void;
                    blur: () => void;
                    select: () => void;
                    clear: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex')[],
                'search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        placeholder: {
                            type: StringConstructor;
                            default: string;
                        };
                        readonly: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        useCaseSensitive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        useRegex: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        modelValue: {
                            type: StringConstructor;
                            default: string;
                        };
                        caseSensitive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        regex: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        styleSet: {
                            type: PropType<string | VsSearchInputStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        onSearch?: ((...args: any[]) => any) | undefined;
                        'onUpdate:caseSensitive'?: ((...args: any[]) => any) | undefined;
                        'onUpdate:regex'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    placeholder: string;
                    readonly: boolean;
                    disabled: boolean;
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    modelValue: string;
                    useCaseSensitive: boolean;
                    useRegex: boolean;
                    caseSensitive: boolean;
                    regex: boolean;
                },
                {},
                {
                    VsInput: DefineComponent<
                        ExtractPropTypes<{
                            autocomplete: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            noClear: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<VsInputType>;
                                default: string;
                            };
                            modelValue: {
                                type: PropType<VsInputValueType>;
                                default: null;
                            };
                            modelModifiers: {
                                type: PropType<StringModifiers>;
                                default: () => {};
                            };
                            min: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            max: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            messages: {
                                type: PropType<Message<VsInputValueType>[]>;
                                default: () => Message<VsInputValueType>[];
                            };
                            name: {
                                type: typeof String;
                                default: string;
                            };
                            noDefaultRules: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            placeholder: {
                                type: typeof String;
                                default: string;
                            };
                            readonly: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            rules: {
                                type: PropType<Rule<VsInputValueType>[]>;
                                default: () => Rule<VsInputValueType>[];
                            };
                            state: {
                                type: PropType<UIState>;
                                default: UIState;
                            };
                            changed: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            valid: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                        }>,
                        {
                            inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                            classObj: ComputedRef<{
                                [x: string]: boolean;
                                'vs-focus-visible': boolean;
                                'vs-focus-within': boolean;
                                'vs-disabled': boolean;
                                'vs-readonly': boolean;
                            }>;
                            colorSchemeClass: ComputedRef<string>;
                            componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                            inputValue: Ref<VsInputValueType, VsInputValueType>;
                            computedMessages: ComputedRef<StateMessage<UIState>[]>;
                            computedDisabled: ComputedRef<boolean>;
                            computedReadonly: ComputedRef<boolean>;
                            renderClearButton: ComputedRef<boolean>;
                            shake: Ref<boolean, boolean>;
                            stateBoxClasses: ComputedRef<{}>;
                            computedId: ComputedRef<string>;
                            onInput: (event: Event) => void;
                            focus: () => void;
                            blur: () => void;
                            select: () => void;
                            clear: () => void;
                            reset: () => void;
                            onFocus: (e: FocusEvent) => void;
                            onBlur: (e: FocusEvent) => void;
                            validate: () => boolean;
                            clearWithFocus: () => void;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        (
                            | 'blur'
                            | 'change'
                            | 'focus'
                            | 'clear'
                            | 'update:modelValue'
                            | 'update:changed'
                            | 'update:valid'
                        )[],
                        'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                autocomplete: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                noClear: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<VsInputType>;
                                    default: string;
                                };
                                modelValue: {
                                    type: PropType<VsInputValueType>;
                                    default: null;
                                };
                                modelModifiers: {
                                    type: PropType<StringModifiers>;
                                    default: () => {};
                                };
                                min: {
                                    type: PropType<number | string>;
                                    default: string | number;
                                    validator: (value: number | string) => boolean;
                                };
                                max: {
                                    type: PropType<number | string>;
                                    default: string | number;
                                    validator: (value: number | string) => boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                messages: {
                                    type: PropType<Message<VsInputValueType>[]>;
                                    default: () => Message<VsInputValueType>[];
                                };
                                name: {
                                    type: typeof String;
                                    default: string;
                                };
                                noDefaultRules: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                placeholder: {
                                    type: typeof String;
                                    default: string;
                                };
                                readonly: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                rules: {
                                    type: PropType<Rule<VsInputValueType>[]>;
                                    default: () => Rule<VsInputValueType>[];
                                };
                                state: {
                                    type: PropType<UIState>;
                                    default: UIState;
                                };
                                changed: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                valid: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                            }>
                        > &
                            Readonly<{
                                onFocus?: ((...args: any[]) => any) | undefined;
                                onBlur?: ((...args: any[]) => any) | undefined;
                                onChange?: ((...args: any[]) => any) | undefined;
                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                onClear?: ((...args: any[]) => any) | undefined;
                                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            label: string;
                            messages: Message<VsInputValueType>[];
                            name: string;
                            noDefaultRules: boolean;
                            placeholder: string;
                            readonly: boolean;
                            rules: Rule<VsInputValueType>[];
                            state: UIState;
                            changed: boolean;
                            valid: boolean;
                            disabled: boolean;
                            hidden: boolean;
                            id: string;
                            noLabel: boolean;
                            noMessages: boolean;
                            required: boolean;
                            min: string | number;
                            max: string | number;
                            type: VsInputType;
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            modelValue: VsInputValueType;
                            autocomplete: boolean;
                            noClear: boolean;
                            modelModifiers: StringModifiers;
                        },
                        {},
                        {
                            VsInputWrapper: DefineComponent<
                                ExtractPropTypes<{
                                    groupLabel: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    messages: {
                                        type: PropType<StateMessage<UIState>[]>;
                                        default: () => never[];
                                    };
                                    shake: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsInputWrapperStyleSet>;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>,
                                {
                                    needToShake: Ref<boolean, boolean>;
                                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        groupLabel: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        messages: {
                                            type: PropType<StateMessage<UIState>[]>;
                                            default: () => never[];
                                        };
                                        shake: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsInputWrapperStyleSet>;
                                        };
                                        disabled: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        hidden: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        id: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        label: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noLabel: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        noMessages: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        required: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    label: string;
                                    messages: StateMessage<UIState>[];
                                    disabled: boolean;
                                    hidden: boolean;
                                    id: string;
                                    noLabel: boolean;
                                    noMessages: boolean;
                                    required: boolean;
                                    groupLabel: boolean;
                                    shake: boolean;
                                },
                                {},
                                {
                                    VsResponsive: DefineComponent<
                                        ExtractPropTypes<{
                                            tag: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>,
                                        {
                                            responsiveClasses: ComputedRef<string[]>;
                                            responsiveStyles: ComputedRef<Record<string, string>>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                tag: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            tag: string;
                                        },
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                    VsMessage: DefineComponent<
                                        ExtractPropTypes<{
                                            state: {
                                                type: PropType<UIState>;
                                                default: string;
                                            };
                                            text: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsMessageStyleSet>;
                                            };
                                        }>,
                                        {
                                            colorClass: ComputedRef<
                                                | 'vs-cs-blue'
                                                | 'vs-cs-green'
                                                | 'vs-cs-amber'
                                                | 'vs-cs-red'
                                                | 'vs-cs-default'
                                            >;
                                            icon: ComputedRef<Component>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                state: {
                                                    type: PropType<UIState>;
                                                    default: string;
                                                };
                                                text: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsMessageStyleSet>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            text: string;
                                            state: UIState;
                                        },
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            XIcon: LucideIcon;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsToggle: DefineComponent<
                        ExtractPropTypes<{
                            modelValue: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsToggleStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            toggle: () => void;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        ('toggle' | 'update:modelValue')[],
                        'toggle' | 'update:modelValue',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                modelValue: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                circle: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                responsive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<'button' | 'submit' | 'reset'>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsToggleStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{
                                onToggle?: ((...args: any[]) => any) | undefined;
                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            circle: boolean;
                            disabled: boolean;
                            type: 'button' | 'reset' | 'submit';
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            outline: boolean;
                            primary: boolean;
                            modelValue: boolean;
                            ghost: boolean;
                            loading: boolean;
                            responsive: boolean;
                        },
                        {},
                        {
                            VsButton: DefineComponent<
                                ExtractPropTypes<{
                                    circle: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    ghost: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    loading: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    outline: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    primary: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    responsive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    type: {
                                        type: PropType<'button' | 'submit' | 'reset'>;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsButtonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    colorSchemeClass: ComputedRef<string>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                    classObj: ComputedRef<{
                                        [x: string]: boolean;
                                        'vs-focus-visible': boolean;
                                        'vs-circle': boolean;
                                        'vs-disabled': boolean;
                                        'vs-ghost': boolean;
                                        'vs-loading-state': boolean;
                                        'vs-outline': boolean;
                                        'vs-primary': boolean;
                                        'vs-responsive': boolean;
                                    }>;
                                    buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                    componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        circle: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        ghost: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        loading: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        outline: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        primary: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        responsive: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        type: {
                                            type: PropType<'button' | 'submit' | 'reset'>;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsButtonStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    circle: boolean;
                                    disabled: boolean;
                                    type: 'button' | 'reset' | 'submit';
                                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                    outline: boolean;
                                    primary: boolean;
                                    ghost: boolean;
                                    loading: boolean;
                                    responsive: boolean;
                                },
                                {},
                                {
                                    VsLoading: DefineComponent<
                                        ExtractPropTypes<{
                                            width: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            styleSet: {
                                                type: PropType<string | VsLoadingStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>,
                                        {
                                            colorSchemeClass: ComputedRef<string>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                width: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                height: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsLoadingStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {},
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsTablePagination: DefineComponent<
                {},
                {
                    pagination: ComputedRef<VsTablePaginationOptions>;
                    page: WritableComputedRef<number, number>;
                    pageSize: WritableComputedRef<number, number>;
                    pageSizeOptions: ComputedRef<VsTablePageSizeOptions>;
                    totalPages: ComputedRef<number>;
                    totalItems: ComputedRef<number>;
                    pageStartIndex: ComputedRef<number>;
                    pageEndIndex: ComputedRef<number>;
                    loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                    primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                    size:
                        | Ref<
                              'xs' | 'sm' | 'md' | 'lg' | 'xl' | undefined,
                              'xs' | 'sm' | 'md' | 'lg' | 'xl' | undefined
                          >
                        | undefined;
                    colorScheme:
                        | ComputedRef<
                              | 'brown'
                              | 'red'
                              | 'orange'
                              | 'amber'
                              | 'yellow'
                              | 'lime'
                              | 'green'
                              | 'emerald'
                              | 'teal'
                              | 'cyan'
                              | 'sky'
                              | 'blue'
                              | 'indigo'
                              | 'violet'
                              | 'purple'
                              | 'fuchsia'
                              | 'pink'
                              | 'rose'
                              | 'gray'
                              | 'none'
                              | undefined
                          >
                        | undefined;
                    tableStyleSet: ComputedRef<VsTableStyleSet> | undefined;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<{}> & Readonly<{}>,
                {},
                {},
                {
                    VsPagination: DefineComponent<
                        ExtractPropTypes<{
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            edgeButtons: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            length: {
                                type: NumberConstructor;
                                required: true;
                                default: number;
                                validator: (value: number) => boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            showingLength: {
                                type: NumberConstructor;
                                default: number;
                                validator: (value: number) => boolean;
                            };
                            modelValue: {
                                type: NumberConstructor;
                                default: number;
                            };
                            styleSet: {
                                type: PropType<string | VsPaginationStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            computedColorScheme: ComputedRef<
                                | 'brown'
                                | 'red'
                                | 'orange'
                                | 'amber'
                                | 'yellow'
                                | 'lime'
                                | 'green'
                                | 'emerald'
                                | 'teal'
                                | 'cyan'
                                | 'sky'
                                | 'blue'
                                | 'indigo'
                                | 'violet'
                                | 'purple'
                                | 'fuchsia'
                                | 'pink'
                                | 'rose'
                                | 'gray'
                                | 'none'
                                | undefined
                            >;
                            colorSchemeClass: ComputedRef<string>;
                            sizeClass: ComputedRef<string>;
                            componentStyleSet: ComputedRef<Partial<VsPaginationStyleSet>>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                            selectedIndex: Ref<number, number>;
                            pages: ComputedRef<number[]>;
                            getPageButtonStyleSet: (page: number) => Omit<VsButtonStyleSet, '$loading'>;
                            goFirst: () => void;
                            goLast: () => void;
                            goPrev: () => void;
                            goNext: () => void;
                            setPage: (page: number) => void;
                            selectIndex: (index: number) => void;
                            isFirstEdge: ComputedRef<boolean>;
                            isLastEdge: ComputedRef<boolean>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        ('change' | 'update:modelValue')[],
                        'change' | 'update:modelValue',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                edgeButtons: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                length: {
                                    type: NumberConstructor;
                                    required: true;
                                    default: number;
                                    validator: (value: number) => boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                showingLength: {
                                    type: NumberConstructor;
                                    default: number;
                                    validator: (value: number) => boolean;
                                };
                                modelValue: {
                                    type: NumberConstructor;
                                    default: number;
                                };
                                styleSet: {
                                    type: PropType<string | VsPaginationStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{
                                onChange?: ((...args: any[]) => any) | undefined;
                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            disabled: boolean;
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            length: number;
                            outline: boolean;
                            modelValue: number;
                            ghost: boolean;
                            edgeButtons: boolean;
                            showingLength: number;
                        },
                        {},
                        {
                            VsButton: DefineComponent<
                                ExtractPropTypes<{
                                    circle: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    ghost: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    loading: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    outline: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    primary: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    responsive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    type: {
                                        type: PropType<'button' | 'submit' | 'reset'>;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsButtonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    colorSchemeClass: ComputedRef<string>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                    classObj: ComputedRef<{
                                        [x: string]: boolean;
                                        'vs-focus-visible': boolean;
                                        'vs-circle': boolean;
                                        'vs-disabled': boolean;
                                        'vs-ghost': boolean;
                                        'vs-loading-state': boolean;
                                        'vs-outline': boolean;
                                        'vs-primary': boolean;
                                        'vs-responsive': boolean;
                                    }>;
                                    buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                    componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        circle: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        ghost: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        loading: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        outline: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        primary: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        responsive: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        type: {
                                            type: PropType<'button' | 'submit' | 'reset'>;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsButtonStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    circle: boolean;
                                    disabled: boolean;
                                    type: 'button' | 'reset' | 'submit';
                                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                    outline: boolean;
                                    primary: boolean;
                                    ghost: boolean;
                                    loading: boolean;
                                    responsive: boolean;
                                },
                                {},
                                {
                                    VsLoading: DefineComponent<
                                        ExtractPropTypes<{
                                            width: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            styleSet: {
                                                type: PropType<string | VsLoadingStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>,
                                        {
                                            colorSchemeClass: ComputedRef<string>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                width: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                height: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsLoadingStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {},
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            ChevronFirstIcon: LucideIcon;
                            ChevronLastIcon: LucideIcon;
                            ChevronLeftIcon: LucideIcon;
                            ChevronRightIcon: LucideIcon;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsSelect: DefineComponent<
                        ExtractPropTypes<{
                            closableChips: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            collapseChips: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            multiple: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            noClear: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            optionsDisabled: {
                                type: PropType<boolean | ((option: any, index: number, options: any[]) => boolean)>;
                                default: boolean;
                            };
                            selectAll: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            modelValue: {
                                type: null;
                                default: null;
                            };
                            search: {
                                type: PropType<SearchProps>;
                                default: boolean;
                                validator: (value: SearchProps) => boolean;
                            };
                            min: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            max: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            groupBy: {
                                type: PropType<(option: any, index: number) => string | null> | null;
                                default: null;
                            };
                            groupOrder: {
                                type: PropType<string[]>;
                                default: () => never[];
                            };
                            options: {
                                type: PropType<any[]>;
                                default: () => never[];
                            };
                            optionLabel: {
                                type: StringConstructor;
                                default: string;
                            };
                            optionValue: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsSelectStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            messages: {
                                type: PropType<Message<any>[]>;
                                default: () => Message<any>[];
                            };
                            name: {
                                type: typeof String;
                                default: string;
                            };
                            noDefaultRules: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            placeholder: {
                                type: typeof String;
                                default: string;
                            };
                            readonly: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            rules: {
                                type: PropType<Rule<any>[]>;
                                default: () => Rule<any>[];
                            };
                            state: {
                                type: PropType<UIState>;
                                default: UIState;
                            };
                            changed: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            valid: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                        }>,
                        {
                            triggerRef: Readonly<ShallowRef<VsSelectTriggerRef | null>>;
                            searchInputRef: Readonly<ShallowRef<VsSearchInputRef | null>>;
                            optionsListRef: Readonly<ShallowRef<VsGroupedListRef | null>>;
                            triggerId: ComputedRef<string>;
                            optionsId: ComputedRef<string>;
                            isOpen: Ref<boolean, boolean>;
                            inputValue: Ref<any, any>;
                            colorSchemeClass: ComputedRef<string>;
                            sizeClass: ComputedRef<string>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentStyleSet: ComputedRef<Partial<VsSelectStyleSet>>;
                            classObj: ComputedRef<{
                                [x: string]: boolean;
                                'vs-disabled': boolean;
                                'vs-readonly': boolean;
                            }>;
                            computedId: ComputedRef<string>;
                            computedMessages: ComputedRef<StateMessage<UIState>[]>;
                            computedState: ComputedRef<UIState>;
                            computedDisabled: ComputedRef<boolean>;
                            computedReadonly: ComputedRef<boolean>;
                            filteredOptions: ComputedRef<OptionItem[]>;
                            shake: Ref<boolean, boolean>;
                            openOptions: () => void;
                            closeOptions: () => void;
                            isSelected: (optionId: string) => boolean;
                            toggleSelectAll: () => void;
                            isUsingSearch: ComputedRef<boolean>;
                            searchProps: ComputedRef<{
                                useRegex: boolean;
                                useCaseSensitive: boolean;
                                placeholder: string;
                            }>;
                            toggleOpen: () => void;
                            selectOptionItem: (optionItem: OptionItem) => void;
                            isSelectedAll: ComputedRef<boolean>;
                            computedColorScheme: ComputedRef<
                                | 'brown'
                                | 'red'
                                | 'orange'
                                | 'amber'
                                | 'yellow'
                                | 'lime'
                                | 'green'
                                | 'emerald'
                                | 'teal'
                                | 'cyan'
                                | 'sky'
                                | 'blue'
                                | 'indigo'
                                | 'violet'
                                | 'purple'
                                | 'fuchsia'
                                | 'pink'
                                | 'rose'
                                | 'gray'
                                | 'none'
                                | undefined
                            >;
                            onFocus: (e: FocusEvent) => void;
                            onBlur: (e: FocusEvent) => void;
                            focus: () => void;
                            blur: () => void;
                            validate: () => boolean;
                            clear: () => void;
                            reset: () => void;
                            isEmpty: ComputedRef<boolean>;
                            selectedOptions: ComputedRef<OptionItem[]>;
                            deselectOption: (optionId: string) => void;
                            getOptionStyleSet: (optionId: string) => CSSProperties;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        (
                            | 'blur'
                            | 'change'
                            | 'close'
                            | 'focus'
                            | 'open'
                            | 'clear'
                            | 'update:modelValue'
                            | 'update:changed'
                            | 'update:valid'
                            | 'click-option'
                        )[],
                        | 'blur'
                        | 'change'
                        | 'close'
                        | 'focus'
                        | 'open'
                        | 'clear'
                        | 'update:modelValue'
                        | 'update:changed'
                        | 'update:valid'
                        | 'click-option',
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                closableChips: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                collapseChips: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                multiple: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                noClear: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                optionsDisabled: {
                                    type: PropType<boolean | ((option: any, index: number, options: any[]) => boolean)>;
                                    default: boolean;
                                };
                                selectAll: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                modelValue: {
                                    type: null;
                                    default: null;
                                };
                                search: {
                                    type: PropType<SearchProps>;
                                    default: boolean;
                                    validator: (value: SearchProps) => boolean;
                                };
                                min: {
                                    type: PropType<number | string>;
                                    default: string | number;
                                    validator: (value: number | string) => boolean;
                                };
                                max: {
                                    type: PropType<number | string>;
                                    default: string | number;
                                    validator: (value: number | string) => boolean;
                                };
                                groupBy: {
                                    type: PropType<(option: any, index: number) => string | null> | null;
                                    default: null;
                                };
                                groupOrder: {
                                    type: PropType<string[]>;
                                    default: () => never[];
                                };
                                options: {
                                    type: PropType<any[]>;
                                    default: () => never[];
                                };
                                optionLabel: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                optionValue: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsSelectStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                messages: {
                                    type: PropType<Message<any>[]>;
                                    default: () => Message<any>[];
                                };
                                name: {
                                    type: typeof String;
                                    default: string;
                                };
                                noDefaultRules: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                placeholder: {
                                    type: typeof String;
                                    default: string;
                                };
                                readonly: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                rules: {
                                    type: PropType<Rule<any>[]>;
                                    default: () => Rule<any>[];
                                };
                                state: {
                                    type: PropType<UIState>;
                                    default: UIState;
                                };
                                changed: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                valid: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                            }>
                        > &
                            Readonly<{
                                onFocus?: ((...args: any[]) => any) | undefined;
                                onBlur?: ((...args: any[]) => any) | undefined;
                                onChange?: ((...args: any[]) => any) | undefined;
                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                onClear?: ((...args: any[]) => any) | undefined;
                                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                                onClose?: ((...args: any[]) => any) | undefined;
                                onOpen?: ((...args: any[]) => any) | undefined;
                                'onClick-option'?: ((...args: any[]) => any) | undefined;
                            }>,
                        {
                            label: string;
                            search: SearchProps;
                            messages: Message<any>[];
                            name: string;
                            noDefaultRules: boolean;
                            placeholder: string;
                            readonly: boolean;
                            rules: Rule<any>[];
                            state: UIState;
                            changed: boolean;
                            valid: boolean;
                            disabled: boolean;
                            hidden: boolean;
                            id: string;
                            noLabel: boolean;
                            noMessages: boolean;
                            required: boolean;
                            min: string | number;
                            max: string | number;
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            multiple: boolean;
                            modelValue: any;
                            options: any[];
                            optionLabel: string;
                            optionValue: string;
                            noClear: boolean;
                            groupBy: (option: any, index: number) => string | null;
                            groupOrder: string[];
                            collapseChips: boolean;
                            closableChips: boolean;
                            optionsDisabled: boolean | ((option: any, index: number, options: any[]) => boolean);
                            selectAll: boolean;
                        },
                        {},
                        {
                            VsFloating: DefineComponent<
                                ExtractPropTypes<{
                                    followWidth: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    overlayId: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    modelValue: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    target: {
                                        type: StringConstructor;
                                        required: boolean;
                                        default: string;
                                    };
                                    align: {
                                        type: PropType<Alignment>;
                                        default: 'start' | 'center' | 'end';
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    enterDelay: {
                                        type: (StringConstructor | NumberConstructor)[];
                                        default: number;
                                    };
                                    leaveDelay: {
                                        type: (StringConstructor | NumberConstructor)[];
                                        default: number;
                                    };
                                    margin: {
                                        type: (StringConstructor | NumberConstructor)[];
                                        default: number;
                                    };
                                    noAnimation: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    placement: {
                                        type: PropType<Placement>;
                                        default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                                    };
                                }>,
                                {
                                    floatingRef: Readonly<ShallowRef<HTMLElement | null>>;
                                    computedPlacement: Ref<
                                        'top' | 'right' | 'bottom' | 'left' | 'middle' | null,
                                        'top' | 'right' | 'bottom' | 'left' | 'middle' | null
                                    >;
                                    isVisible: Ref<boolean, boolean>;
                                    isFloated: Ref<boolean, boolean>;
                                    animationClass: ComputedRef<string | null>;
                                    floatingStyle: ComputedRef<
                                        | {
                                              animationDelay?: undefined;
                                          }
                                        | {
                                              animationDelay: string;
                                          }
                                    >;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                'update:modelValue'[],
                                'update:modelValue',
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        followWidth: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        overlayId: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        modelValue: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        target: {
                                            type: StringConstructor;
                                            required: boolean;
                                            default: string;
                                        };
                                        align: {
                                            type: PropType<Alignment>;
                                            default: 'start' | 'center' | 'end';
                                        };
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        enterDelay: {
                                            type: (StringConstructor | NumberConstructor)[];
                                            default: number;
                                        };
                                        leaveDelay: {
                                            type: (StringConstructor | NumberConstructor)[];
                                            default: number;
                                        };
                                        margin: {
                                            type: (StringConstructor | NumberConstructor)[];
                                            default: number;
                                        };
                                        noAnimation: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        placement: {
                                            type: PropType<Placement>;
                                            default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                                        };
                                    }>
                                > &
                                    Readonly<{
                                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                    }>,
                                {
                                    disabled: boolean;
                                    margin: string | number;
                                    modelValue: boolean;
                                    target: string;
                                    placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                                    overlayId: string;
                                    followWidth: boolean;
                                    align: 'start' | 'center' | 'end';
                                    enterDelay: string | number;
                                    leaveDelay: string | number;
                                    noAnimation: boolean;
                                },
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsInputWrapper: DefineComponent<
                                ExtractPropTypes<{
                                    groupLabel: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    messages: {
                                        type: PropType<StateMessage<UIState>[]>;
                                        default: () => never[];
                                    };
                                    shake: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsInputWrapperStyleSet>;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>,
                                {
                                    needToShake: Ref<boolean, boolean>;
                                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        groupLabel: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        messages: {
                                            type: PropType<StateMessage<UIState>[]>;
                                            default: () => never[];
                                        };
                                        shake: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsInputWrapperStyleSet>;
                                        };
                                        disabled: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        hidden: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        id: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        label: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noLabel: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        noMessages: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        required: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {
                                    label: string;
                                    messages: StateMessage<UIState>[];
                                    disabled: boolean;
                                    hidden: boolean;
                                    id: string;
                                    noLabel: boolean;
                                    noMessages: boolean;
                                    required: boolean;
                                    groupLabel: boolean;
                                    shake: boolean;
                                },
                                {},
                                {
                                    VsResponsive: DefineComponent<
                                        ExtractPropTypes<{
                                            tag: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>,
                                        {
                                            responsiveClasses: ComputedRef<string[]>;
                                            responsiveStyles: ComputedRef<Record<string, string>>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                tag: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            tag: string;
                                        },
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                    VsMessage: DefineComponent<
                                        ExtractPropTypes<{
                                            state: {
                                                type: PropType<UIState>;
                                                default: string;
                                            };
                                            text: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsMessageStyleSet>;
                                            };
                                        }>,
                                        {
                                            colorClass: ComputedRef<
                                                | 'vs-cs-blue'
                                                | 'vs-cs-green'
                                                | 'vs-cs-amber'
                                                | 'vs-cs-red'
                                                | 'vs-cs-default'
                                            >;
                                            icon: ComputedRef<Component>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                state: {
                                                    type: PropType<UIState>;
                                                    default: string;
                                                };
                                                text: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsMessageStyleSet>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            text: string;
                                            state: UIState;
                                        },
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsSearchInput: DefineComponent<
                                ExtractPropTypes<{
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    placeholder: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    readonly: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    useCaseSensitive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    useRegex: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    modelValue: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    caseSensitive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    regex: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsSearchInputStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    inputRef: Readonly<ShallowRef<VsInputRef | null>>;
                                    searchText: Ref<string, string>;
                                    isCaseSensitiveOn: Ref<boolean, boolean>;
                                    isRegexOn: Ref<boolean, boolean>;
                                    computedColorScheme: ComputedRef<
                                        | 'brown'
                                        | 'red'
                                        | 'orange'
                                        | 'amber'
                                        | 'yellow'
                                        | 'lime'
                                        | 'green'
                                        | 'emerald'
                                        | 'teal'
                                        | 'cyan'
                                        | 'sky'
                                        | 'blue'
                                        | 'indigo'
                                        | 'violet'
                                        | 'purple'
                                        | 'fuchsia'
                                        | 'pink'
                                        | 'rose'
                                        | 'gray'
                                        | 'none'
                                        | undefined
                                    >;
                                    componentStyleSet: ComputedRef<Partial<VsSearchInputStyleSet>>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    onInputChange: (value: string | number | null) => void;
                                    match: (text: string) => boolean;
                                    focus: () => void;
                                    blur: () => void;
                                    select: () => void;
                                    clear: () => void;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                ('search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex')[],
                                'search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex',
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        placeholder: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        readonly: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        useCaseSensitive: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        useRegex: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        modelValue: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        caseSensitive: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        regex: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsSearchInputStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{
                                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                        onSearch?: ((...args: any[]) => any) | undefined;
                                        'onUpdate:caseSensitive'?: ((...args: any[]) => any) | undefined;
                                        'onUpdate:regex'?: ((...args: any[]) => any) | undefined;
                                    }>,
                                {
                                    placeholder: string;
                                    readonly: boolean;
                                    disabled: boolean;
                                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                    modelValue: string;
                                    useCaseSensitive: boolean;
                                    useRegex: boolean;
                                    caseSensitive: boolean;
                                    regex: boolean;
                                },
                                {},
                                {
                                    VsInput: DefineComponent<
                                        ExtractPropTypes<{
                                            autocomplete: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            noClear: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            type: {
                                                type: PropType<VsInputType>;
                                                default: string;
                                            };
                                            modelValue: {
                                                type: PropType<VsInputValueType>;
                                                default: null;
                                            };
                                            modelModifiers: {
                                                type: PropType<StringModifiers>;
                                                default: () => {};
                                            };
                                            min: {
                                                type: PropType<number | string>;
                                                default: string | number;
                                                validator: (value: number | string) => boolean;
                                            };
                                            max: {
                                                type: PropType<number | string>;
                                                default: string | number;
                                                validator: (value: number | string) => boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsInputStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            label: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            messages: {
                                                type: PropType<Message<VsInputValueType>[]>;
                                                default: () => Message<VsInputValueType>[];
                                            };
                                            name: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noDefaultRules: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            placeholder: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            readonly: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            rules: {
                                                type: PropType<Rule<VsInputValueType>[]>;
                                                default: () => Rule<VsInputValueType>[];
                                            };
                                            state: {
                                                type: PropType<UIState>;
                                                default: UIState;
                                            };
                                            changed: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            valid: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            disabled: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            hidden: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            id: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noLabel: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            noMessages: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            required: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                        }>,
                                        {
                                            inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                                            classObj: ComputedRef<{
                                                [x: string]: boolean;
                                                'vs-focus-visible': boolean;
                                                'vs-focus-within': boolean;
                                                'vs-disabled': boolean;
                                                'vs-readonly': boolean;
                                            }>;
                                            colorSchemeClass: ComputedRef<string>;
                                            componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                            inputValue: Ref<VsInputValueType, VsInputValueType>;
                                            computedMessages: ComputedRef<StateMessage<UIState>[]>;
                                            computedDisabled: ComputedRef<boolean>;
                                            computedReadonly: ComputedRef<boolean>;
                                            renderClearButton: ComputedRef<boolean>;
                                            shake: Ref<boolean, boolean>;
                                            stateBoxClasses: ComputedRef<{}>;
                                            computedId: ComputedRef<string>;
                                            onInput: (event: Event) => void;
                                            focus: () => void;
                                            blur: () => void;
                                            select: () => void;
                                            clear: () => void;
                                            reset: () => void;
                                            onFocus: (e: FocusEvent) => void;
                                            onBlur: (e: FocusEvent) => void;
                                            validate: () => boolean;
                                            clearWithFocus: () => void;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        (
                                            | 'blur'
                                            | 'change'
                                            | 'focus'
                                            | 'clear'
                                            | 'update:modelValue'
                                            | 'update:changed'
                                            | 'update:valid'
                                        )[],
                                        | 'blur'
                                        | 'change'
                                        | 'focus'
                                        | 'clear'
                                        | 'update:modelValue'
                                        | 'update:changed'
                                        | 'update:valid',
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                autocomplete: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                noClear: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                size: {
                                                    type: PropType<Size>;
                                                    default: string;
                                                };
                                                type: {
                                                    type: PropType<VsInputType>;
                                                    default: string;
                                                };
                                                modelValue: {
                                                    type: PropType<VsInputValueType>;
                                                    default: null;
                                                };
                                                modelModifiers: {
                                                    type: PropType<StringModifiers>;
                                                    default: () => {};
                                                };
                                                min: {
                                                    type: PropType<number | string>;
                                                    default: string | number;
                                                    validator: (value: number | string) => boolean;
                                                };
                                                max: {
                                                    type: PropType<number | string>;
                                                    default: string | number;
                                                    validator: (value: number | string) => boolean;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsInputStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                label: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                messages: {
                                                    type: PropType<Message<VsInputValueType>[]>;
                                                    default: () => Message<VsInputValueType>[];
                                                };
                                                name: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                noDefaultRules: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                placeholder: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                readonly: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                rules: {
                                                    type: PropType<Rule<VsInputValueType>[]>;
                                                    default: () => Rule<VsInputValueType>[];
                                                };
                                                state: {
                                                    type: PropType<UIState>;
                                                    default: UIState;
                                                };
                                                changed: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                valid: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                disabled: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                hidden: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                id: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                noLabel: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                noMessages: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                required: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                            }>
                                        > &
                                            Readonly<{
                                                onFocus?: ((...args: any[]) => any) | undefined;
                                                onBlur?: ((...args: any[]) => any) | undefined;
                                                onChange?: ((...args: any[]) => any) | undefined;
                                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                                onClear?: ((...args: any[]) => any) | undefined;
                                                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                                            }>,
                                        {
                                            label: string;
                                            messages: Message<VsInputValueType>[];
                                            name: string;
                                            noDefaultRules: boolean;
                                            placeholder: string;
                                            readonly: boolean;
                                            rules: Rule<VsInputValueType>[];
                                            state: UIState;
                                            changed: boolean;
                                            valid: boolean;
                                            disabled: boolean;
                                            hidden: boolean;
                                            id: string;
                                            noLabel: boolean;
                                            noMessages: boolean;
                                            required: boolean;
                                            min: string | number;
                                            max: string | number;
                                            type: VsInputType;
                                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                            modelValue: VsInputValueType;
                                            autocomplete: boolean;
                                            noClear: boolean;
                                            modelModifiers: StringModifiers;
                                        },
                                        {},
                                        {
                                            VsInputWrapper: DefineComponent<
                                                ExtractPropTypes<{
                                                    groupLabel: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    messages: {
                                                        type: PropType<StateMessage<UIState>[]>;
                                                        default: () => never[];
                                                    };
                                                    shake: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsInputWrapperStyleSet>;
                                                    };
                                                    disabled: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    hidden: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    id: {
                                                        type: typeof String;
                                                        default: string;
                                                    };
                                                    label: {
                                                        type: typeof String;
                                                        default: string;
                                                    };
                                                    noLabel: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    noMessages: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    required: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    width: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                    grid: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                }>,
                                                {
                                                    needToShake: Ref<boolean, boolean>;
                                                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                                },
                                                {},
                                                {},
                                                {},
                                                ComponentOptionsMixin,
                                                ComponentOptionsMixin,
                                                {},
                                                string,
                                                PublicProps,
                                                Readonly<
                                                    ExtractPropTypes<{
                                                        groupLabel: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        messages: {
                                                            type: PropType<StateMessage<UIState>[]>;
                                                            default: () => never[];
                                                        };
                                                        shake: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        styleSet: {
                                                            type: PropType<string | VsInputWrapperStyleSet>;
                                                        };
                                                        disabled: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        hidden: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        id: {
                                                            type: typeof String;
                                                            default: string;
                                                        };
                                                        label: {
                                                            type: typeof String;
                                                            default: string;
                                                        };
                                                        noLabel: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        noMessages: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        required: {
                                                            type: typeof Boolean;
                                                            default: boolean;
                                                        };
                                                        width: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                        grid: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                    }>
                                                > &
                                                    Readonly<{}>,
                                                {
                                                    label: string;
                                                    messages: StateMessage<UIState>[];
                                                    disabled: boolean;
                                                    hidden: boolean;
                                                    id: string;
                                                    noLabel: boolean;
                                                    noMessages: boolean;
                                                    required: boolean;
                                                    groupLabel: boolean;
                                                    shake: boolean;
                                                },
                                                {},
                                                {
                                                    VsResponsive: DefineComponent<
                                                        ExtractPropTypes<{
                                                            tag: {
                                                                type: StringConstructor;
                                                                default: string;
                                                            };
                                                            width: {
                                                                type: PropType<string | number | Breakpoints>;
                                                            };
                                                            grid: {
                                                                type: PropType<string | number | Breakpoints>;
                                                            };
                                                        }>,
                                                        {
                                                            responsiveClasses: ComputedRef<string[]>;
                                                            responsiveStyles: ComputedRef<Record<string, string>>;
                                                        },
                                                        {},
                                                        {},
                                                        {},
                                                        ComponentOptionsMixin,
                                                        ComponentOptionsMixin,
                                                        {},
                                                        string,
                                                        PublicProps,
                                                        Readonly<
                                                            ExtractPropTypes<{
                                                                tag: {
                                                                    type: StringConstructor;
                                                                    default: string;
                                                                };
                                                                width: {
                                                                    type: PropType<string | number | Breakpoints>;
                                                                };
                                                                grid: {
                                                                    type: PropType<string | number | Breakpoints>;
                                                                };
                                                            }>
                                                        > &
                                                            Readonly<{}>,
                                                        {
                                                            tag: string;
                                                        },
                                                        {},
                                                        {},
                                                        {},
                                                        string,
                                                        ComponentProvideOptions,
                                                        true,
                                                        {},
                                                        any
                                                    >;
                                                    VsMessage: DefineComponent<
                                                        ExtractPropTypes<{
                                                            state: {
                                                                type: PropType<UIState>;
                                                                default: string;
                                                            };
                                                            text: {
                                                                type: StringConstructor;
                                                                default: string;
                                                            };
                                                            styleSet: {
                                                                type: PropType<string | VsMessageStyleSet>;
                                                            };
                                                        }>,
                                                        {
                                                            colorClass: ComputedRef<
                                                                | 'vs-cs-blue'
                                                                | 'vs-cs-green'
                                                                | 'vs-cs-amber'
                                                                | 'vs-cs-red'
                                                                | 'vs-cs-default'
                                                            >;
                                                            icon: ComputedRef<Component>;
                                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                                        },
                                                        {},
                                                        {},
                                                        {},
                                                        ComponentOptionsMixin,
                                                        ComponentOptionsMixin,
                                                        {},
                                                        string,
                                                        PublicProps,
                                                        Readonly<
                                                            ExtractPropTypes<{
                                                                state: {
                                                                    type: PropType<UIState>;
                                                                    default: string;
                                                                };
                                                                text: {
                                                                    type: StringConstructor;
                                                                    default: string;
                                                                };
                                                                styleSet: {
                                                                    type: PropType<string | VsMessageStyleSet>;
                                                                };
                                                            }>
                                                        > &
                                                            Readonly<{}>,
                                                        {
                                                            text: string;
                                                            state: UIState;
                                                        },
                                                        {},
                                                        {},
                                                        {},
                                                        string,
                                                        ComponentProvideOptions,
                                                        true,
                                                        {},
                                                        any
                                                    >;
                                                },
                                                {},
                                                string,
                                                ComponentProvideOptions,
                                                true,
                                                {},
                                                any
                                            >;
                                            XIcon: LucideIcon;
                                        },
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                    VsToggle: DefineComponent<
                                        ExtractPropTypes<{
                                            modelValue: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            circle: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            disabled: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            ghost: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            loading: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            outline: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            primary: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            responsive: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            type: {
                                                type: PropType<'button' | 'submit' | 'reset'>;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsToggleStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>,
                                        {
                                            colorSchemeClass: ComputedRef<string>;
                                            componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            toggle: () => void;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        ('toggle' | 'update:modelValue')[],
                                        'toggle' | 'update:modelValue',
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                modelValue: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                circle: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                disabled: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                ghost: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                loading: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                outline: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                primary: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                responsive: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                size: {
                                                    type: PropType<Size>;
                                                    default: string;
                                                };
                                                type: {
                                                    type: PropType<'button' | 'submit' | 'reset'>;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsToggleStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>
                                        > &
                                            Readonly<{
                                                onToggle?: ((...args: any[]) => any) | undefined;
                                                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                            }>,
                                        {
                                            circle: boolean;
                                            disabled: boolean;
                                            type: 'button' | 'reset' | 'submit';
                                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                            outline: boolean;
                                            primary: boolean;
                                            modelValue: boolean;
                                            ghost: boolean;
                                            loading: boolean;
                                            responsive: boolean;
                                        },
                                        {},
                                        {
                                            VsButton: DefineComponent<
                                                ExtractPropTypes<{
                                                    circle: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    disabled: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    ghost: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    loading: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    outline: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    primary: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    responsive: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    size: {
                                                        type: PropType<Size>;
                                                        default: string;
                                                    };
                                                    type: {
                                                        type: PropType<'button' | 'submit' | 'reset'>;
                                                        default: string;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsButtonStyleSet>;
                                                    };
                                                    colorScheme: {
                                                        type: PropType<ColorScheme>;
                                                    };
                                                }>,
                                                {
                                                    colorSchemeClass: ComputedRef<string>;
                                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                                    classObj: ComputedRef<{
                                                        [x: string]: boolean;
                                                        'vs-focus-visible': boolean;
                                                        'vs-circle': boolean;
                                                        'vs-disabled': boolean;
                                                        'vs-ghost': boolean;
                                                        'vs-loading-state': boolean;
                                                        'vs-outline': boolean;
                                                        'vs-primary': boolean;
                                                        'vs-responsive': boolean;
                                                    }>;
                                                    buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                                    componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                                                },
                                                {},
                                                {},
                                                {},
                                                ComponentOptionsMixin,
                                                ComponentOptionsMixin,
                                                {},
                                                string,
                                                PublicProps,
                                                Readonly<
                                                    ExtractPropTypes<{
                                                        circle: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        disabled: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        ghost: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        loading: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        outline: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        primary: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        responsive: {
                                                            type: BooleanConstructor;
                                                            default: boolean;
                                                        };
                                                        size: {
                                                            type: PropType<Size>;
                                                            default: string;
                                                        };
                                                        type: {
                                                            type: PropType<'button' | 'submit' | 'reset'>;
                                                            default: string;
                                                        };
                                                        styleSet: {
                                                            type: PropType<string | VsButtonStyleSet>;
                                                        };
                                                        colorScheme: {
                                                            type: PropType<ColorScheme>;
                                                        };
                                                    }>
                                                > &
                                                    Readonly<{}>,
                                                {
                                                    circle: boolean;
                                                    disabled: boolean;
                                                    type: 'button' | 'reset' | 'submit';
                                                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                                    outline: boolean;
                                                    primary: boolean;
                                                    ghost: boolean;
                                                    loading: boolean;
                                                    responsive: boolean;
                                                },
                                                {},
                                                {
                                                    VsLoading: DefineComponent<
                                                        ExtractPropTypes<{
                                                            width: {
                                                                type: (StringConstructor | NumberConstructor)[];
                                                            };
                                                            height: {
                                                                type: (StringConstructor | NumberConstructor)[];
                                                            };
                                                            styleSet: {
                                                                type: PropType<string | VsLoadingStyleSet>;
                                                            };
                                                            colorScheme: {
                                                                type: PropType<ColorScheme>;
                                                            };
                                                        }>,
                                                        {
                                                            colorSchemeClass: ComputedRef<string>;
                                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                                        },
                                                        {},
                                                        {},
                                                        {},
                                                        ComponentOptionsMixin,
                                                        ComponentOptionsMixin,
                                                        {},
                                                        string,
                                                        PublicProps,
                                                        Readonly<
                                                            ExtractPropTypes<{
                                                                width: {
                                                                    type: (StringConstructor | NumberConstructor)[];
                                                                };
                                                                height: {
                                                                    type: (StringConstructor | NumberConstructor)[];
                                                                };
                                                                styleSet: {
                                                                    type: PropType<string | VsLoadingStyleSet>;
                                                                };
                                                                colorScheme: {
                                                                    type: PropType<ColorScheme>;
                                                                };
                                                            }>
                                                        > &
                                                            Readonly<{}>,
                                                        {},
                                                        {},
                                                        {},
                                                        {},
                                                        string,
                                                        ComponentProvideOptions,
                                                        true,
                                                        {},
                                                        any
                                                    >;
                                                },
                                                {},
                                                string,
                                                ComponentProvideOptions,
                                                true,
                                                {},
                                                any
                                            >;
                                        },
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsCheckbox: DefineComponent<
                                ExtractPropTypes<{
                                    beforeChange: {
                                        type: PropType<
                                            (from: any, to: any, optionValue: any) => Promise<boolean> | null
                                        >;
                                        default: null;
                                    };
                                    checked: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    checkLabel: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    indeterminate: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    multiple: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    trueValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    falseValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    modelValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    messages: {
                                        type: PropType<Message<any>[]>;
                                        default: () => Message<any>[];
                                    };
                                    name: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noDefaultRules: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    readonly: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    rules: {
                                        type: PropType<Rule<any>[]>;
                                        default: () => Rule<any>[];
                                    };
                                    state: {
                                        type: PropType<UIState>;
                                        default: UIState;
                                    };
                                    changed: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    valid: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsCheckboxStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                                    colorSchemeClass: ComputedRef<string>;
                                    componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                    classObj: ComputedRef<{
                                        'vs-checked': boolean;
                                        'vs-disabled': boolean;
                                        'vs-focus-visible': boolean;
                                        'vs-indeterminate': boolean;
                                        'vs-readonly': boolean;
                                    }>;
                                    sizeClass: ComputedRef<string>;
                                    stateBoxClasses: ComputedRef<{}>;
                                    computedId: ComputedRef<string>;
                                    computedDisabled: ComputedRef<boolean>;
                                    computedReadonly: ComputedRef<boolean>;
                                    computedMessages: ComputedRef<StateMessage<UIState>[]>;
                                    computedState: ComputedRef<UIState>;
                                    convertToString: (value: any) => string;
                                    inputValue: Ref<any, any>;
                                    isChecked: ComputedRef<boolean>;
                                    shake: Ref<boolean, boolean>;
                                    toggle: (e: MouseEvent) => Promise<void>;
                                    onFocus: (e: FocusEvent) => void;
                                    onBlur: (e: FocusEvent) => void;
                                    validate: () => boolean;
                                    clear: () => void;
                                    reset: () => void;
                                    focus: () => void;
                                    blur: () => void;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                (
                                    | 'blur'
                                    | 'change'
                                    | 'focus'
                                    | 'toggle'
                                    | 'clear'
                                    | 'update:modelValue'
                                    | 'update:changed'
                                    | 'update:valid'
                                )[],
                                | 'blur'
                                | 'change'
                                | 'focus'
                                | 'toggle'
                                | 'clear'
                                | 'update:modelValue'
                                | 'update:changed'
                                | 'update:valid',
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        beforeChange: {
                                            type: PropType<
                                                (from: any, to: any, optionValue: any) => Promise<boolean> | null
                                            >;
                                            default: null;
                                        };
                                        checked: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        checkLabel: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        indeterminate: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        multiple: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        trueValue: {
                                            type: null;
                                            default: boolean;
                                        };
                                        falseValue: {
                                            type: null;
                                            default: boolean;
                                        };
                                        modelValue: {
                                            type: null;
                                            default: boolean;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        label: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        messages: {
                                            type: PropType<Message<any>[]>;
                                            default: () => Message<any>[];
                                        };
                                        name: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noDefaultRules: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        readonly: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        rules: {
                                            type: PropType<Rule<any>[]>;
                                            default: () => Rule<any>[];
                                        };
                                        state: {
                                            type: PropType<UIState>;
                                            default: UIState;
                                        };
                                        changed: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        valid: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        hidden: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        id: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noLabel: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        noMessages: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        required: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsCheckboxStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{
                                        onFocus?: ((...args: any[]) => any) | undefined;
                                        onBlur?: ((...args: any[]) => any) | undefined;
                                        onChange?: ((...args: any[]) => any) | undefined;
                                        onToggle?: ((...args: any[]) => any) | undefined;
                                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                        onClear?: ((...args: any[]) => any) | undefined;
                                        'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                        'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                                    }>,
                                {
                                    label: string;
                                    messages: Message<any>[];
                                    name: string;
                                    noDefaultRules: boolean;
                                    readonly: boolean;
                                    rules: Rule<any>[];
                                    state: UIState;
                                    changed: boolean;
                                    valid: boolean;
                                    disabled: boolean;
                                    hidden: boolean;
                                    id: string;
                                    noLabel: boolean;
                                    noMessages: boolean;
                                    required: boolean;
                                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                    multiple: boolean;
                                    modelValue: any;
                                    beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                                    checked: boolean;
                                    checkLabel: string;
                                    indeterminate: boolean;
                                    trueValue: any;
                                    falseValue: any;
                                },
                                {},
                                {
                                    VsInputWrapper: DefineComponent<
                                        ExtractPropTypes<{
                                            groupLabel: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            messages: {
                                                type: PropType<StateMessage<UIState>[]>;
                                                default: () => never[];
                                            };
                                            shake: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsInputWrapperStyleSet>;
                                            };
                                            disabled: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            hidden: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            id: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            label: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noLabel: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            noMessages: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            required: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>,
                                        {
                                            needToShake: Ref<boolean, boolean>;
                                            componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                groupLabel: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                messages: {
                                                    type: PropType<StateMessage<UIState>[]>;
                                                    default: () => never[];
                                                };
                                                shake: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsInputWrapperStyleSet>;
                                                };
                                                disabled: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                hidden: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                id: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                label: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                noLabel: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                noMessages: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                required: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            label: string;
                                            messages: StateMessage<UIState>[];
                                            disabled: boolean;
                                            hidden: boolean;
                                            id: string;
                                            noLabel: boolean;
                                            noMessages: boolean;
                                            required: boolean;
                                            groupLabel: boolean;
                                            shake: boolean;
                                        },
                                        {},
                                        {
                                            VsResponsive: DefineComponent<
                                                ExtractPropTypes<{
                                                    tag: {
                                                        type: StringConstructor;
                                                        default: string;
                                                    };
                                                    width: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                    grid: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                }>,
                                                {
                                                    responsiveClasses: ComputedRef<string[]>;
                                                    responsiveStyles: ComputedRef<Record<string, string>>;
                                                },
                                                {},
                                                {},
                                                {},
                                                ComponentOptionsMixin,
                                                ComponentOptionsMixin,
                                                {},
                                                string,
                                                PublicProps,
                                                Readonly<
                                                    ExtractPropTypes<{
                                                        tag: {
                                                            type: StringConstructor;
                                                            default: string;
                                                        };
                                                        width: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                        grid: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                    }>
                                                > &
                                                    Readonly<{}>,
                                                {
                                                    tag: string;
                                                },
                                                {},
                                                {},
                                                {},
                                                string,
                                                ComponentProvideOptions,
                                                true,
                                                {},
                                                any
                                            >;
                                            VsMessage: DefineComponent<
                                                ExtractPropTypes<{
                                                    state: {
                                                        type: PropType<UIState>;
                                                        default: string;
                                                    };
                                                    text: {
                                                        type: StringConstructor;
                                                        default: string;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsMessageStyleSet>;
                                                    };
                                                }>,
                                                {
                                                    colorClass: ComputedRef<
                                                        | 'vs-cs-blue'
                                                        | 'vs-cs-green'
                                                        | 'vs-cs-amber'
                                                        | 'vs-cs-red'
                                                        | 'vs-cs-default'
                                                    >;
                                                    icon: ComputedRef<Component>;
                                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                                },
                                                {},
                                                {},
                                                {},
                                                ComponentOptionsMixin,
                                                ComponentOptionsMixin,
                                                {},
                                                string,
                                                PublicProps,
                                                Readonly<
                                                    ExtractPropTypes<{
                                                        state: {
                                                            type: PropType<UIState>;
                                                            default: string;
                                                        };
                                                        text: {
                                                            type: StringConstructor;
                                                            default: string;
                                                        };
                                                        styleSet: {
                                                            type: PropType<string | VsMessageStyleSet>;
                                                        };
                                                    }>
                                                > &
                                                    Readonly<{}>,
                                                {
                                                    text: string;
                                                    state: UIState;
                                                },
                                                {},
                                                {},
                                                {},
                                                string,
                                                ComponentProvideOptions,
                                                true,
                                                {},
                                                any
                                            >;
                                        },
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsGroupedList: DefineComponent<
                                ExtractPropTypes<{
                                    items: {
                                        type: PropType<OptionItem[]>;
                                        default: () => never[];
                                    };
                                    groupBy: {
                                        type: PropType<(option: any, index: number) => string | null> | null;
                                        default: null;
                                    };
                                    groupOrder: {
                                        type: PropType<string[]>;
                                        default: () => never[];
                                    };
                                    styleSet: {
                                        type: PropType<string | VsGroupedListStyleSet>;
                                    };
                                }>,
                                {
                                    visibleRenderRef: Readonly<ShallowRef<VsVisibleRenderRef | null>>;
                                    innerScrollRef: Readonly<ShallowRef<VsInnerScrollRef | null>>;
                                    componentStyleSet: ComputedRef<Partial<VsGroupedListStyleSet>>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                    groupedItems: ComputedRef<VsGroupedListGroup[]>;
                                    emitClickItem: (
                                        item: OptionItem,
                                        groupedIndex: number,
                                        group: VsGroupedListGroup,
                                        groupIndex: number,
                                    ) => void;
                                    scrollToItem: (id: string) => void;
                                    hasScroll: () => boolean;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                'click-item'[],
                                'click-item',
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        items: {
                                            type: PropType<OptionItem[]>;
                                            default: () => never[];
                                        };
                                        groupBy: {
                                            type: PropType<(option: any, index: number) => string | null> | null;
                                            default: null;
                                        };
                                        groupOrder: {
                                            type: PropType<string[]>;
                                            default: () => never[];
                                        };
                                        styleSet: {
                                            type: PropType<string | VsGroupedListStyleSet>;
                                        };
                                    }>
                                > &
                                    Readonly<{
                                        'onClick-item'?: ((...args: any[]) => any) | undefined;
                                    }>,
                                {
                                    items: OptionItem[];
                                    groupBy: (option: any, index: number) => string | null;
                                    groupOrder: string[];
                                },
                                {},
                                {
                                    VsInnerScroll: DefineComponent<
                                        ExtractPropTypes<{
                                            hideScroll: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsInnerScrollStyleSet>;
                                            };
                                        }>,
                                        {
                                            componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                            hasScroll: () => boolean;
                                            bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                hideScroll: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsInnerScrollStyleSet>;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            hideScroll: boolean;
                                        },
                                        {},
                                        {},
                                        {
                                            scrollShadow: Directive<HTMLElement, boolean | undefined>;
                                        },
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                    VsVisibleRender: DefineComponent<
                                        ExtractPropTypes<{
                                            selector: {
                                                type: StringConstructor;
                                                default: null;
                                            };
                                            disabled: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            rootMargin: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            tag: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            threshold: {
                                                type: NumberConstructor;
                                                default: number;
                                                validator: (value: number) => boolean;
                                            };
                                        }>,
                                        {
                                            containerStyle: ComputedRef<
                                                | {
                                                      height?: undefined;
                                                      overflowY?: undefined;
                                                  }
                                                | {
                                                      height: string;
                                                      overflowY: string;
                                                  }
                                            >;
                                            scrollToElement: (element: HTMLElement) => void;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        {},
                                        string,
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                selector: {
                                                    type: StringConstructor;
                                                    default: null;
                                                };
                                                disabled: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                height: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                rootMargin: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                tag: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                threshold: {
                                                    type: NumberConstructor;
                                                    default: number;
                                                    validator: (value: number) => boolean;
                                                };
                                            }>
                                        > &
                                            Readonly<{}>,
                                        {
                                            disabled: boolean;
                                            tag: string;
                                            selector: string;
                                            rootMargin: string;
                                            threshold: number;
                                        },
                                        {},
                                        {},
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                            VsSelectTrigger: DefineComponent<
                                ExtractPropTypes<{
                                    styleSet: {
                                        type: PropType<VsSelectStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                    collapseChips: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    closableChips: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    isEmpty: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    isOpen: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    multiple: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    noClear: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    placeholder: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    readonly: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    selectedOptions: {
                                        type: PropType<OptionItem[]>;
                                        default: () => never[];
                                    };
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                }>,
                                {
                                    triggerRef: Readonly<ShallowRef<HTMLElement | null>>;
                                    stateBoxClasses: ComputedRef<{}>;
                                    renderClearButton: ComputedRef<boolean>;
                                    displayLabel: ComputedRef<string>;
                                    triggerClassObj: ComputedRef<{
                                        'vs-focusable': boolean;
                                        'vs-focus-within': boolean;
                                    }>;
                                    componentStyleSet: ComputedRef<Partial<VsSelectStyleSet>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                    focus: () => void;
                                    blur: () => void;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                ('click' | 'blur' | 'focus' | 'clear' | 'deselect')[],
                                'click' | 'blur' | 'focus' | 'clear' | 'deselect',
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        styleSet: {
                                            type: PropType<VsSelectStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                        collapseChips: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        closableChips: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        isEmpty: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        isOpen: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        multiple: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        noClear: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        placeholder: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        readonly: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        selectedOptions: {
                                            type: PropType<OptionItem[]>;
                                            default: () => never[];
                                        };
                                        state: {
                                            type: PropType<UIState>;
                                            default: string;
                                        };
                                    }>
                                > &
                                    Readonly<{
                                        onFocus?: ((...args: any[]) => any) | undefined;
                                        onBlur?: ((...args: any[]) => any) | undefined;
                                        onClick?: ((...args: any[]) => any) | undefined;
                                        onClear?: ((...args: any[]) => any) | undefined;
                                        onDeselect?: ((...args: any[]) => any) | undefined;
                                    }>,
                                {
                                    placeholder: string;
                                    readonly: boolean;
                                    state: UIState;
                                    disabled: boolean;
                                    multiple: boolean;
                                    isOpen: boolean;
                                    noClear: boolean;
                                    collapseChips: boolean;
                                    closableChips: boolean;
                                    isEmpty: boolean;
                                    selectedOptions: OptionItem[];
                                },
                                {},
                                {
                                    VsChip: DefineComponent<
                                        ExtractPropTypes<{
                                            closable: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            outline: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            primary: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsChipStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>,
                                        {
                                            colorSchemeClass: ComputedRef<string>;
                                            componentStyleSet: ComputedRef<Partial<VsChipStyleSet>>;
                                            styleSetVariables: ComputedRef<Record<string, string>>;
                                            componentInlineStyle: ComputedRef<CSSProperties>;
                                            classObj: ComputedRef<{
                                                [x: string]: boolean;
                                                'vs-outline': boolean;
                                                'vs-primary': boolean;
                                            }>;
                                        },
                                        {},
                                        {},
                                        {},
                                        ComponentOptionsMixin,
                                        ComponentOptionsMixin,
                                        'close'[],
                                        'close',
                                        PublicProps,
                                        Readonly<
                                            ExtractPropTypes<{
                                                closable: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                outline: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                primary: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                size: {
                                                    type: PropType<Size>;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsChipStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>
                                        > &
                                            Readonly<{
                                                onClose?: ((...args: any[]) => any) | undefined;
                                            }>,
                                        {
                                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                            outline: boolean;
                                            primary: boolean;
                                            closable: boolean;
                                        },
                                        {},
                                        {
                                            XIcon: LucideIcon;
                                        },
                                        {},
                                        string,
                                        ComponentProvideOptions,
                                        true,
                                        {},
                                        any
                                    >;
                                    ChevronDownIcon: LucideIcon;
                                    XIcon: LucideIcon;
                                },
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsGrid: DefineComponent<
                ExtractPropTypes<{
                    width: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsGridStyleSet>;
                    };
                    gridSize: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    columnGap: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    rowGap: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                }>,
                {
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        width: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsGridStyleSet>;
                        };
                        gridSize: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        columnGap: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        rowGap: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsResponsive: DefineComponent<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    responsiveClasses: ComputedRef<string[]>;
                    responsiveStyles: ComputedRef<Record<string, string>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsTabs: DefineComponent<
        ExtractPropTypes<{
            controls: {
                type: PropType<'hide' | 'show' | 'auto'>;
                default: string;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            disabled: {
                type: PropType<boolean | ((tab: string, index: number) => boolean)>;
                default: boolean;
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            tabs: {
                type: PropType<string[]>;
                default: () => never[];
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: NumberConstructor;
                default: number;
            };
            styleSet: {
                type: PropType<string | VsTabsStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsTabsStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            classObj: ComputedRef<{
                [x: string]: boolean;
                'vs-primary': boolean;
                'vs-vertical': boolean;
            }>;
            getTabStyleSet: (index: number) => CSSProperties;
            isSelected: (index: number) => boolean;
            isDisabled: (index: number) => boolean;
            isAllDisabled: () => boolean;
            selectedIndex: Ref<number, number>;
            selectTab: (index: number) => void;
            isFirstEdge: ComputedRef<boolean>;
            isLastEdge: ComputedRef<boolean>;
            tabsRef: Ref<HTMLElement | null, HTMLElement | null>;
            handleKeydown: (e: KeyboardEvent, isVertical: boolean) => void;
            showControls: ComputedRef<boolean>;
            goPrev: () => void;
            goNext: () => void;
            indicatorStyle: Ref<Record<string, string> | null, Record<string, string> | null>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('change' | 'update:modelValue')[],
        'change' | 'update:modelValue',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                controls: {
                    type: PropType<'hide' | 'show' | 'auto'>;
                    default: string;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                disabled: {
                    type: PropType<boolean | ((tab: string, index: number) => boolean)>;
                    default: boolean;
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tabs: {
                    type: PropType<string[]>;
                    default: () => never[];
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modelValue: {
                    type: NumberConstructor;
                    default: number;
                };
                styleSet: {
                    type: PropType<string | VsTabsStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>
        > &
            Readonly<{
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            disabled: boolean | ((tab: string, index: number) => boolean);
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            vertical: boolean;
            primary: boolean;
            modelValue: number;
            controls: 'auto' | 'hide' | 'show';
            tabs: string[];
        },
        {},
        {
            VsButton: DefineComponent<
                ExtractPropTypes<{
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsButtonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    classObj: ComputedRef<{
                        [x: string]: boolean;
                        'vs-focus-visible': boolean;
                        'vs-circle': boolean;
                        'vs-disabled': boolean;
                        'vs-ghost': boolean;
                        'vs-loading-state': boolean;
                        'vs-outline': boolean;
                        'vs-primary': boolean;
                        'vs-responsive': boolean;
                    }>;
                    buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                    componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsButtonStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    circle: boolean;
                    disabled: boolean;
                    type: 'button' | 'reset' | 'submit';
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    outline: boolean;
                    primary: boolean;
                    ghost: boolean;
                    loading: boolean;
                    responsive: boolean;
                },
                {},
                {
                    VsLoading: DefineComponent<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                width: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                height: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                styleSet: {
                                    type: PropType<string | VsLoadingStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {},
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsResponsive: DefineComponent<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    responsiveClasses: ComputedRef<string[]>;
                    responsiveStyles: ComputedRef<Record<string, string>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    tag: string;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            ChevronLeftIcon: LucideIcon;
            ChevronRightIcon: LucideIcon;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsTextarea: DefineComponent<
        ExtractPropTypes<{
            autocomplete: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: StringConstructor;
                default: string;
            };
            modelModifiers: {
                type: PropType<StringModifiers>;
                default: () => {};
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            styleSet: {
                type: PropType<string | VsTextareaStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<string>[]>;
                default: () => Message<string>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<string>[]>;
                default: () => Rule<string>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>,
        {
            textareaRef: Readonly<ShallowRef<HTMLTextAreaElement | null>>;
            classObj: ComputedRef<{
                'vs-disabled': boolean;
                'vs-readonly': boolean;
                'vs-focus-visible': boolean;
            }>;
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsTextareaStyleSet>>;
            sizeClass: ComputedRef<string>;
            stateBoxClasses: ComputedRef<{}>;
            computedId: ComputedRef<string>;
            computedDisabled: ComputedRef<boolean>;
            computedReadonly: ComputedRef<boolean>;
            computedMessages: ComputedRef<StateMessage<UIState>[]>;
            computedState: ComputedRef<UIState>;
            inputValue: Ref<string, string>;
            shake: Ref<boolean, boolean>;
            updateValue: (event: Event) => void;
            onFocus: (e: FocusEvent) => void;
            onBlur: (e: FocusEvent) => void;
            clear: () => void;
            reset: () => void;
            validate: () => boolean;
            focus: () => void;
            blur: () => void;
            select: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
        'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                autocomplete: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                modelValue: {
                    type: StringConstructor;
                    default: string;
                };
                modelModifiers: {
                    type: PropType<StringModifiers>;
                    default: () => {};
                };
                min: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                max: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                styleSet: {
                    type: PropType<string | VsTextareaStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<string>[]>;
                    default: () => Message<string>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                placeholder: {
                    type: typeof String;
                    default: string;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<string>[]>;
                    default: () => Rule<string>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
            }>
        > &
            Readonly<{
                onFocus?: ((...args: any[]) => any) | undefined;
                onBlur?: ((...args: any[]) => any) | undefined;
                onChange?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                onClear?: ((...args: any[]) => any) | undefined;
                'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            label: string;
            messages: Message<string>[];
            name: string;
            noDefaultRules: boolean;
            placeholder: string;
            readonly: boolean;
            rules: Rule<string>[];
            state: UIState;
            changed: boolean;
            valid: boolean;
            disabled: boolean;
            hidden: boolean;
            id: string;
            noLabel: boolean;
            noMessages: boolean;
            required: boolean;
            min: string | number;
            max: string | number;
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            modelValue: string;
            autocomplete: boolean;
            modelModifiers: StringModifiers;
        },
        {},
        {
            VsInputWrapper: DefineComponent<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>,
                {
                    needToShake: Ref<boolean, boolean>;
                    componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    label: string;
                    messages: StateMessage<UIState>[];
                    disabled: boolean;
                    hidden: boolean;
                    id: string;
                    noLabel: boolean;
                    noMessages: boolean;
                    required: boolean;
                    groupLabel: boolean;
                    shake: boolean;
                },
                {},
                {
                    VsResponsive: DefineComponent<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>,
                        {
                            responsiveClasses: ComputedRef<string[]>;
                            responsiveStyles: ComputedRef<Record<string, string>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            tag: string;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    VsMessage: DefineComponent<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>,
                        {
                            colorClass: ComputedRef<
                                'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                            >;
                            icon: ComputedRef<Component>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            text: string;
                            state: UIState;
                        },
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsTextWrap: DefineComponent<
        ExtractPropTypes<{
            copy: {
                type: BooleanConstructor;
                default: boolean;
            };
            link: {
                type: StringConstructor;
                default: string;
            };
            width: {
                type: PropType<string | number>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsTextWrapStyleSet>;
            };
        }>,
        {
            componentStyleSet: ComputedRef<Partial<VsTextWrapStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            contentText: ComputedRef<string>;
            contentsRef: Ref<HTMLElement | null, HTMLElement | null>;
            copyInnerText: () => Promise<void>;
            openLink: () => void;
            copied: Ref<boolean, boolean>;
            CheckIcon: LucideIcon;
            CopyIcon: LucideIcon;
            LinkIcon: LucideIcon;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'copied'[],
        'copied',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                copy: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                link: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsTextWrapStyleSet>;
                };
            }>
        > &
            Readonly<{
                onCopied?: ((...args: any[]) => any) | undefined;
            }>,
        {
            link: string;
            copy: boolean;
            width: string | number;
        },
        {},
        {
            LinkIcon: LucideIcon;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsThemeButton: DefineComponent<
        ExtractPropTypes<{
            circle: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            ghost: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            type: {
                type: PropType<'button' | 'submit' | 'reset'>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsThemeButtonStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            changeTheme: (isDark: boolean) => void;
            isDarkTheme: ComputedRef<boolean>;
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsThemeButtonStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'change'[],
        'change',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                circle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<'button' | 'submit' | 'reset'>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsThemeButtonStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onChange?: ((...args: any[]) => any) | undefined;
            }>,
        {
            circle: boolean;
            disabled: boolean;
            type: 'button' | 'reset' | 'submit';
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            outline: boolean;
            primary: boolean;
            ghost: boolean;
            loading: boolean;
            responsive: boolean;
        },
        {},
        {
            VsToggle: DefineComponent<
                ExtractPropTypes<{
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsToggleStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    toggle: () => void;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                ('toggle' | 'update:modelValue')[],
                'toggle' | 'update:modelValue',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        modelValue: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsToggleStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        onToggle?: ((...args: any[]) => any) | undefined;
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    circle: boolean;
                    disabled: boolean;
                    type: 'button' | 'reset' | 'submit';
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    outline: boolean;
                    primary: boolean;
                    modelValue: boolean;
                    ghost: boolean;
                    loading: boolean;
                    responsive: boolean;
                },
                {},
                {
                    VsButton: DefineComponent<
                        ExtractPropTypes<{
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsButtonStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                            classObj: ComputedRef<{
                                [x: string]: boolean;
                                'vs-focus-visible': boolean;
                                'vs-circle': boolean;
                                'vs-disabled': boolean;
                                'vs-ghost': boolean;
                                'vs-loading-state': boolean;
                                'vs-outline': boolean;
                                'vs-primary': boolean;
                                'vs-responsive': boolean;
                            }>;
                            buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                            componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                circle: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                responsive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<'button' | 'submit' | 'reset'>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsButtonStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            circle: boolean;
                            disabled: boolean;
                            type: 'button' | 'reset' | 'submit';
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            outline: boolean;
                            primary: boolean;
                            ghost: boolean;
                            loading: boolean;
                            responsive: boolean;
                        },
                        {},
                        {
                            VsLoading: DefineComponent<
                                ExtractPropTypes<{
                                    width: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    height: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    styleSet: {
                                        type: PropType<string | VsLoadingStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    colorSchemeClass: ComputedRef<string>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        width: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        height: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        styleSet: {
                                            type: PropType<string | VsLoadingStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {},
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            MoonIcon: LucideIcon;
            SunIcon: LucideIcon;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsToast: DefineComponent<
        ExtractPropTypes<{
            autoClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            timeout: {
                type: NumberConstructor;
                default: number;
            };
            styleSet: {
                type: PropType<string | VsToastStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            computedColorScheme: ComputedRef<
                | 'brown'
                | 'red'
                | 'orange'
                | 'amber'
                | 'yellow'
                | 'lime'
                | 'green'
                | 'emerald'
                | 'teal'
                | 'cyan'
                | 'sky'
                | 'blue'
                | 'indigo'
                | 'violet'
                | 'purple'
                | 'fuchsia'
                | 'pink'
                | 'rose'
                | 'gray'
                | 'none'
                | undefined
            >;
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsToastStyleSet>>;
            componentInlineStyle: ComputedRef<CSSProperties>;
            onMouseEnter: () => void;
            onMouseLeave: () => void;
            holdToClose: Ref<boolean, boolean>;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        'close'[],
        'close',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                autoClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                timeout: {
                    type: NumberConstructor;
                    default: number;
                };
                styleSet: {
                    type: PropType<string | VsToastStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onClose?: ((...args: any[]) => any) | undefined;
            }>,
        {
            primary: boolean;
            autoClose: boolean;
            timeout: number;
        },
        {},
        {
            VsButton: DefineComponent<
                ExtractPropTypes<{
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsButtonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    classObj: ComputedRef<{
                        [x: string]: boolean;
                        'vs-focus-visible': boolean;
                        'vs-circle': boolean;
                        'vs-disabled': boolean;
                        'vs-ghost': boolean;
                        'vs-loading-state': boolean;
                        'vs-outline': boolean;
                        'vs-primary': boolean;
                        'vs-responsive': boolean;
                    }>;
                    buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                    componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsButtonStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    circle: boolean;
                    disabled: boolean;
                    type: 'button' | 'reset' | 'submit';
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    outline: boolean;
                    primary: boolean;
                    ghost: boolean;
                    loading: boolean;
                    responsive: boolean;
                },
                {},
                {
                    VsLoading: DefineComponent<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                width: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                height: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                styleSet: {
                                    type: PropType<string | VsLoadingStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {},
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            XIcon: LucideIcon;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsToastView: DefineComponent<
        ExtractPropTypes<{
            container: {
                type: StringConstructor;
                default: string;
            };
        }>,
        {
            toastsByPosition: ComputedRef<Record<string, ToastInfo[]>>;
            isFixed: ComputedRef<boolean>;
            removeToast: (id: string) => void;
            getPositionClass: (key: string) => string[];
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                container: {
                    type: StringConstructor;
                    default: string;
                };
            }>
        > &
            Readonly<{}>,
        {
            container: string;
        },
        {},
        {
            VsToast: DefineComponent<
                ExtractPropTypes<{
                    autoClose: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    timeout: {
                        type: NumberConstructor;
                        default: number;
                    };
                    styleSet: {
                        type: PropType<string | VsToastStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    computedColorScheme: ComputedRef<
                        | 'brown'
                        | 'red'
                        | 'orange'
                        | 'amber'
                        | 'yellow'
                        | 'lime'
                        | 'green'
                        | 'emerald'
                        | 'teal'
                        | 'cyan'
                        | 'sky'
                        | 'blue'
                        | 'indigo'
                        | 'violet'
                        | 'purple'
                        | 'fuchsia'
                        | 'pink'
                        | 'rose'
                        | 'gray'
                        | 'none'
                        | undefined
                    >;
                    colorSchemeClass: ComputedRef<string>;
                    componentStyleSet: ComputedRef<Partial<VsToastStyleSet>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    onMouseEnter: () => void;
                    onMouseLeave: () => void;
                    holdToClose: Ref<boolean, boolean>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                'close'[],
                'close',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        autoClose: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        timeout: {
                            type: NumberConstructor;
                            default: number;
                        };
                        styleSet: {
                            type: PropType<string | VsToastStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{
                        onClose?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    primary: boolean;
                    autoClose: boolean;
                    timeout: number;
                },
                {},
                {
                    VsButton: DefineComponent<
                        ExtractPropTypes<{
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsButtonStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                            classObj: ComputedRef<{
                                [x: string]: boolean;
                                'vs-focus-visible': boolean;
                                'vs-circle': boolean;
                                'vs-disabled': boolean;
                                'vs-ghost': boolean;
                                'vs-loading-state': boolean;
                                'vs-outline': boolean;
                                'vs-primary': boolean;
                                'vs-responsive': boolean;
                            }>;
                            buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                            componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                circle: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                responsive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<'button' | 'submit' | 'reset'>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsButtonStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {
                            circle: boolean;
                            disabled: boolean;
                            type: 'button' | 'reset' | 'submit';
                            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                            outline: boolean;
                            primary: boolean;
                            ghost: boolean;
                            loading: boolean;
                            responsive: boolean;
                        },
                        {},
                        {
                            VsLoading: DefineComponent<
                                ExtractPropTypes<{
                                    width: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    height: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    styleSet: {
                                        type: PropType<string | VsLoadingStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>,
                                {
                                    colorSchemeClass: ComputedRef<string>;
                                    styleSetVariables: ComputedRef<Record<string, string>>;
                                    componentInlineStyle: ComputedRef<CSSProperties>;
                                },
                                {},
                                {},
                                {},
                                ComponentOptionsMixin,
                                ComponentOptionsMixin,
                                {},
                                string,
                                PublicProps,
                                Readonly<
                                    ExtractPropTypes<{
                                        width: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        height: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        styleSet: {
                                            type: PropType<string | VsLoadingStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>
                                > &
                                    Readonly<{}>,
                                {},
                                {},
                                {},
                                {},
                                string,
                                ComponentProvideOptions,
                                true,
                                {},
                                any
                            >;
                        },
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                    XIcon: LucideIcon;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
            VsRender: DefineComponent<
                ExtractPropTypes<{
                    content: {
                        type: PropType<string | Component>;
                        required: true;
                    };
                    componentProps: {
                        type: PropType<Record<string, any>>;
                        default: () => {};
                    };
                }>,
                () => VNode<
                    RendererNode,
                    RendererElement,
                    {
                        [key: string]: any;
                    }
                >,
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        content: {
                            type: PropType<string | Component>;
                            required: true;
                        };
                        componentProps: {
                            type: PropType<Record<string, any>>;
                            default: () => {};
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    componentProps: Record<string, any>;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsToggle: DefineComponent<
        ExtractPropTypes<{
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            circle: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            ghost: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            type: {
                type: PropType<'button' | 'submit' | 'reset'>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsToggleStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            toggle: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        ('toggle' | 'update:modelValue')[],
        'toggle' | 'update:modelValue',
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                circle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<'button' | 'submit' | 'reset'>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsToggleStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{
                onToggle?: ((...args: any[]) => any) | undefined;
                'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            }>,
        {
            circle: boolean;
            disabled: boolean;
            type: 'button' | 'reset' | 'submit';
            size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            outline: boolean;
            primary: boolean;
            modelValue: boolean;
            ghost: boolean;
            loading: boolean;
            responsive: boolean;
        },
        {},
        {
            VsButton: DefineComponent<
                ExtractPropTypes<{
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsButtonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>,
                {
                    colorSchemeClass: ComputedRef<string>;
                    styleSetVariables: ComputedRef<Record<string, string>>;
                    componentInlineStyle: ComputedRef<CSSProperties>;
                    classObj: ComputedRef<{
                        [x: string]: boolean;
                        'vs-focus-visible': boolean;
                        'vs-circle': boolean;
                        'vs-disabled': boolean;
                        'vs-ghost': boolean;
                        'vs-loading-state': boolean;
                        'vs-outline': boolean;
                        'vs-primary': boolean;
                        'vs-responsive': boolean;
                    }>;
                    buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                    componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                {},
                string,
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsButtonStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>
                > &
                    Readonly<{}>,
                {
                    circle: boolean;
                    disabled: boolean;
                    type: 'button' | 'reset' | 'submit';
                    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                    outline: boolean;
                    primary: boolean;
                    ghost: boolean;
                    loading: boolean;
                    responsive: boolean;
                },
                {},
                {
                    VsLoading: DefineComponent<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>,
                        {
                            colorSchemeClass: ComputedRef<string>;
                            styleSetVariables: ComputedRef<Record<string, string>>;
                            componentInlineStyle: ComputedRef<CSSProperties>;
                        },
                        {},
                        {},
                        {},
                        ComponentOptionsMixin,
                        ComponentOptionsMixin,
                        {},
                        string,
                        PublicProps,
                        Readonly<
                            ExtractPropTypes<{
                                width: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                height: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                styleSet: {
                                    type: PropType<string | VsLoadingStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>
                        > &
                            Readonly<{}>,
                        {},
                        {},
                        {},
                        {},
                        string,
                        ComponentProvideOptions,
                        true,
                        {},
                        any
                    >;
                },
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsTooltip: DefineComponent<
        ExtractPropTypes<{
            target: {
                type: StringConstructor;
                default: string;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            clickable: {
                type: BooleanConstructor;
                default: boolean;
            };
            contentsHover: {
                type: BooleanConstructor;
                default: boolean;
            };
            escClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            align: {
                type: PropType<Alignment>;
                default: 'start' | 'center' | 'end';
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            enterDelay: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            leaveDelay: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            margin: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            noAnimation: {
                type: BooleanConstructor;
                default: boolean;
            };
            placement: {
                type: PropType<Placement>;
                default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
            };
            styleSet: {
                type: PropType<string | VsTooltipStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>,
        {
            colorSchemeClass: ComputedRef<string>;
            styleSetVariables: ComputedRef<Record<string, string>>;
            componentStyleSet: ComputedRef<Partial<VsTooltipStyleSet>>;
            computedShow: WritableComputedRef<boolean, boolean>;
            triggerClass: ComputedRef<string>;
            effectiveTarget: ComputedRef<string>;
            onTooltipEnter: () => void;
            onTooltipLeave: () => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                target: {
                    type: StringConstructor;
                    default: string;
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                clickable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                contentsHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                escClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                align: {
                    type: PropType<Alignment>;
                    default: 'start' | 'center' | 'end';
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                enterDelay: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                leaveDelay: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                margin: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                noAnimation: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                placement: {
                    type: PropType<Placement>;
                    default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                };
                styleSet: {
                    type: PropType<string | VsTooltipStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>
        > &
            Readonly<{}>,
        {
            disabled: boolean;
            margin: string | number;
            tag: string;
            target: string;
            placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
            escClose: boolean;
            align: 'start' | 'center' | 'end';
            enterDelay: string | number;
            leaveDelay: string | number;
            noAnimation: boolean;
            clickable: boolean;
            contentsHover: boolean;
        },
        {},
        {
            VsFloating: DefineComponent<
                ExtractPropTypes<{
                    followWidth: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    overlayId: {
                        type: StringConstructor;
                        default: string;
                    };
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    target: {
                        type: StringConstructor;
                        required: boolean;
                        default: string;
                    };
                    align: {
                        type: PropType<Alignment>;
                        default: 'start' | 'center' | 'end';
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    enterDelay: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    leaveDelay: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    margin: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    noAnimation: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placement: {
                        type: PropType<Placement>;
                        default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                    };
                }>,
                {
                    floatingRef: Readonly<ShallowRef<HTMLElement | null>>;
                    computedPlacement: Ref<
                        'top' | 'right' | 'bottom' | 'left' | 'middle' | null,
                        'top' | 'right' | 'bottom' | 'left' | 'middle' | null
                    >;
                    isVisible: Ref<boolean, boolean>;
                    isFloated: Ref<boolean, boolean>;
                    animationClass: ComputedRef<string | null>;
                    floatingStyle: ComputedRef<
                        | {
                              animationDelay?: undefined;
                          }
                        | {
                              animationDelay: string;
                          }
                    >;
                },
                {},
                {},
                {},
                ComponentOptionsMixin,
                ComponentOptionsMixin,
                'update:modelValue'[],
                'update:modelValue',
                PublicProps,
                Readonly<
                    ExtractPropTypes<{
                        followWidth: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        overlayId: {
                            type: StringConstructor;
                            default: string;
                        };
                        modelValue: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        target: {
                            type: StringConstructor;
                            required: boolean;
                            default: string;
                        };
                        align: {
                            type: PropType<Alignment>;
                            default: 'start' | 'center' | 'end';
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        enterDelay: {
                            type: (StringConstructor | NumberConstructor)[];
                            default: number;
                        };
                        leaveDelay: {
                            type: (StringConstructor | NumberConstructor)[];
                            default: number;
                        };
                        margin: {
                            type: (StringConstructor | NumberConstructor)[];
                            default: number;
                        };
                        noAnimation: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        placement: {
                            type: PropType<Placement>;
                            default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                        };
                    }>
                > &
                    Readonly<{
                        'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    }>,
                {
                    disabled: boolean;
                    margin: string | number;
                    modelValue: boolean;
                    target: string;
                    placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                    overlayId: string;
                    followWidth: boolean;
                    align: 'start' | 'center' | 'end';
                    enterDelay: string | number;
                    leaveDelay: string | number;
                    noAnimation: boolean;
                },
                {},
                {},
                {},
                string,
                ComponentProvideOptions,
                true,
                {},
                any
            >;
        },
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
    readonly VsVisibleRender: DefineComponent<
        ExtractPropTypes<{
            selector: {
                type: StringConstructor;
                default: null;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            rootMargin: {
                type: StringConstructor;
                default: string;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            threshold: {
                type: NumberConstructor;
                default: number;
                validator: (value: number) => boolean;
            };
        }>,
        {
            containerStyle: ComputedRef<
                | {
                      height?: undefined;
                      overflowY?: undefined;
                  }
                | {
                      height: string;
                      overflowY: string;
                  }
            >;
            scrollToElement: (element: HTMLElement) => void;
        },
        {},
        {},
        {},
        ComponentOptionsMixin,
        ComponentOptionsMixin,
        {},
        string,
        PublicProps,
        Readonly<
            ExtractPropTypes<{
                selector: {
                    type: StringConstructor;
                    default: null;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                rootMargin: {
                    type: StringConstructor;
                    default: string;
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                threshold: {
                    type: NumberConstructor;
                    default: number;
                    validator: (value: number) => boolean;
                };
            }>
        > &
            Readonly<{}>,
        {
            disabled: boolean;
            tag: string;
            selector: string;
            rootMargin: string;
            threshold: number;
        },
        {},
        {},
        {},
        string,
        ComponentProvideOptions,
        true,
        {},
        any
    >;
};

export declare interface VlossomOptions {
    components: {
        [key: string]: Component;
    };
    colorScheme?: GlobalColorSchemes;
    styleSet?: GlobalStyleSets;
    theme?: Theme;
    radiusRatio?: number;
}

export declare const VsAccordion: DefineComponent<
    ExtractPropTypes<{
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        open: {
            type: BooleanConstructor;
            default: boolean;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        modelValue: {
            type: BooleanConstructor;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsAccordionStyleSet>;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentStyleSet: ComputedRef<Partial<VsAccordionStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        isOpen: Ref<boolean, boolean>;
        classObj: ComputedRef<{
            [x: string]: boolean;
            'vs-focus-visible': boolean;
            'vs-disabled': boolean;
            'vs-primary': boolean;
        }>;
        toggle: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('toggle' | 'update:modelValue')[],
    'toggle' | 'update:modelValue',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            open: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsAccordionStyleSet>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onToggle?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        disabled: boolean;
        open: boolean;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        primary: boolean;
        modelValue: boolean;
    },
    {},
    {
        VsResponsive: DefineComponent<
            ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                responsiveClasses: ComputedRef<string[]>;
                responsiveStyles: ComputedRef<Record<string, string>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsExpandable: DefineComponent<
            ExtractPropTypes<{
                open: {
                    type: BooleanConstructor;
                    required: true;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsExpandableStyleSet>;
                };
            }>,
            {
                sizeClass: ComputedRef<string>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                beforeEnter: (el: Element) => void;
                enter: (el: Element, done: () => void) => void;
                beforeLeave: (el: Element) => void;
                leave: (el: Element, done: () => void) => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    open: {
                        type: BooleanConstructor;
                        required: true;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsExpandableStyleSet>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsAccordionRef extends ComponentPublicInstance<typeof VsAccordion> {
    toggle: () => void;
}

export declare interface VsAccordionStyleSet extends CSSProperties {
    $accordionBorder?: string;
    $arrowColor?: string;
    $arrowSize?: string;
    $arrowSpacing?: string;
    $title?: CSSProperties;
    $content?: VsExpandableStyleSet;
}

declare interface VsAlertStyleSet extends VsModalNodeStyleSet {
    $buttons?: CSSProperties;
    $okButton?: Omit<VsButtonStyleSet, '$loading'>;
}

export declare const VsAvatar: DefineComponent<
    ExtractPropTypes<{
        styleSet: {
            type: PropType<string | VsAvatarStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            styleSet: {
                type: PropType<string | VsAvatarStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {},
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsAvatarRef extends ComponentPublicInstance<typeof VsAvatar> {}

export declare interface VsAvatarStyleSet extends CSSProperties {
    $imageObjectFit?: CSSProperties['objectFit'] & {};
}

export declare const VsBar: DefineComponent<
    ExtractPropTypes<{
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        position: {
            type: PropType<CssPosition>;
        };
        styleSet: {
            type: PropType<string | VsBarStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            'vs-primary': boolean;
        }>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            position: {
                type: PropType<CssPosition>;
            };
            styleSet: {
                type: PropType<string | VsBarStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {
        tag: string;
        primary: boolean;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsBarRef extends ComponentPublicInstance<typeof VsBar> {}

export declare interface VsBarStyleSet extends CSSProperties {}

export declare const VsBlock: DefineComponent<
    ExtractPropTypes<{
        height: {
            type: (StringConstructor | NumberConstructor)[];
        };
        styleSet: {
            type: PropType<string | VsBlockStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsBlockStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            styleSet: {
                type: PropType<string | VsBlockStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>
    > &
        Readonly<{}>,
    {},
    {},
    {
        VsResponsive: DefineComponent<
            ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                responsiveClasses: ComputedRef<string[]>;
                responsiveStyles: ComputedRef<Record<string, string>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsInnerScroll: DefineComponent<
            ExtractPropTypes<{
                hideScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInnerScrollStyleSet>;
                };
            }>,
            {
                componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                hasScroll: () => boolean;
                bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    hideScroll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInnerScrollStyleSet>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                hideScroll: boolean;
            },
            {},
            {},
            {
                scrollShadow: Directive<HTMLElement, boolean | undefined>;
            },
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsBlockRef extends ComponentPublicInstance<typeof VsBlock> {}

export declare interface VsBlockStyleSet extends CSSProperties {
    $blockBorder?: string;
    $title?: CSSProperties;
    $content?: CSSProperties;
}

export declare const VsButton: DefineComponent<
    ExtractPropTypes<{
        circle: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        ghost: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        outline: {
            type: BooleanConstructor;
            default: boolean;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        responsive: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        type: {
            type: PropType<'button' | 'submit' | 'reset'>;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsButtonStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            [x: string]: boolean;
            'vs-focus-visible': boolean;
            'vs-circle': boolean;
            'vs-disabled': boolean;
            'vs-ghost': boolean;
            'vs-loading-state': boolean;
            'vs-outline': boolean;
            'vs-primary': boolean;
            'vs-responsive': boolean;
        }>;
        buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
        componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            circle: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            ghost: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            type: {
                type: PropType<'button' | 'submit' | 'reset'>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsButtonStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {
        circle: boolean;
        disabled: boolean;
        type: 'button' | 'reset' | 'submit';
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        outline: boolean;
        primary: boolean;
        ghost: boolean;
        loading: boolean;
        responsive: boolean;
    },
    {},
    {
        VsLoading: DefineComponent<
            ExtractPropTypes<{
                width: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                styleSet: {
                    type: PropType<string | VsLoadingStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    width: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    styleSet: {
                        type: PropType<string | VsLoadingStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{}>,
            {},
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsButtonRef extends ComponentPublicInstance<typeof VsButton> {}

export declare interface VsButtonStyleSet extends CSSProperties {
    $content?: CSSProperties;
    $loading?: VsLoadingStyleSet;
}

export declare const VsCheckbox: DefineComponent<
    ExtractPropTypes<{
        beforeChange: {
            type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
            default: null;
        };
        checked: {
            type: BooleanConstructor;
            default: boolean;
        };
        checkLabel: {
            type: StringConstructor;
            default: string;
        };
        indeterminate: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        trueValue: {
            type: null;
            default: boolean;
        };
        falseValue: {
            type: null;
            default: boolean;
        };
        modelValue: {
            type: null;
            default: boolean;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<any>[]>;
            default: () => Message<any>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<any>[]>;
            default: () => Rule<any>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsCheckboxStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            'vs-checked': boolean;
            'vs-disabled': boolean;
            'vs-focus-visible': boolean;
            'vs-indeterminate': boolean;
            'vs-readonly': boolean;
        }>;
        sizeClass: ComputedRef<string>;
        stateBoxClasses: ComputedRef<{}>;
        computedId: ComputedRef<string>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        computedState: ComputedRef<UIState>;
        convertToString: (value: any) => string;
        inputValue: Ref<any, any>;
        isChecked: ComputedRef<boolean>;
        shake: Ref<boolean, boolean>;
        toggle: (e: MouseEvent) => Promise<void>;
        onFocus: (e: FocusEvent) => void;
        onBlur: (e: FocusEvent) => void;
        validate: () => boolean;
        clear: () => void;
        reset: () => void;
        focus: () => void;
        blur: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
    'blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                default: null;
            };
            checked: {
                type: BooleanConstructor;
                default: boolean;
            };
            checkLabel: {
                type: StringConstructor;
                default: string;
            };
            indeterminate: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            trueValue: {
                type: null;
                default: boolean;
            };
            falseValue: {
                type: null;
                default: boolean;
            };
            modelValue: {
                type: null;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsCheckboxStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            onToggle?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        messages: Message<any>[];
        name: string;
        noDefaultRules: boolean;
        readonly: boolean;
        rules: Rule<any>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        multiple: boolean;
        modelValue: any;
        beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
        checked: boolean;
        checkLabel: string;
        indeterminate: boolean;
        trueValue: any;
        falseValue: any;
    },
    {},
    {
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsCheckboxRef extends ComponentPublicInstance<typeof VsCheckbox>, FocusableRef, FormChildRef {
    toggle: () => void;
}

export declare const VsCheckboxSet: DefineComponent<
    ExtractPropTypes<{
        beforeChange: {
            type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
            default: null;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        vertical: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: PropType<any[]>;
            default: () => never[];
        };
        min: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        max: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        options: {
            type: PropType<any[]>;
            default: () => never[];
        };
        optionLabel: {
            type: StringConstructor;
            default: string;
        };
        optionValue: {
            type: StringConstructor;
            default: string;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<any[]>[]>;
            default: () => Message<any[]>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<any[]>[]>;
            default: () => Rule<any[]>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsCheckboxSetStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        checkboxRefs: Readonly<
            ShallowRef<
                | CreateComponentPublicInstanceWithMixins<
                      Readonly<
                          ExtractPropTypes<{
                              beforeChange: {
                                  type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                  default: null;
                              };
                              checked: {
                                  type: BooleanConstructor;
                                  default: boolean;
                              };
                              checkLabel: {
                                  type: StringConstructor;
                                  default: string;
                              };
                              indeterminate: {
                                  type: BooleanConstructor;
                                  default: boolean;
                              };
                              multiple: {
                                  type: BooleanConstructor;
                                  default: boolean;
                              };
                              size: {
                                  type: PropType<Size>;
                                  default: string;
                              };
                              trueValue: {
                                  type: null;
                                  default: boolean;
                              };
                              falseValue: {
                                  type: null;
                                  default: boolean;
                              };
                              modelValue: {
                                  type: null;
                                  default: boolean;
                              };
                              width: {
                                  type: PropType<string | number | Breakpoints>;
                              };
                              grid: {
                                  type: PropType<string | number | Breakpoints>;
                              };
                              label: {
                                  type: typeof String;
                                  default: string;
                              };
                              messages: {
                                  type: PropType<Message<any>[]>;
                                  default: () => Message<any>[];
                              };
                              name: {
                                  type: typeof String;
                                  default: string;
                              };
                              noDefaultRules: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              readonly: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              rules: {
                                  type: PropType<Rule<any>[]>;
                                  default: () => Rule<any>[];
                              };
                              state: {
                                  type: PropType<UIState>;
                                  default: UIState;
                              };
                              changed: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              valid: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              disabled: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              hidden: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              id: {
                                  type: typeof String;
                                  default: string;
                              };
                              noLabel: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              noMessages: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              required: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              styleSet: {
                                  type: PropType<string | VsCheckboxStyleSet>;
                              };
                              colorScheme: {
                                  type: PropType<ColorScheme>;
                              };
                          }>
                      > &
                          Readonly<{
                              onFocus?: ((...args: any[]) => any) | undefined;
                              onBlur?: ((...args: any[]) => any) | undefined;
                              onChange?: ((...args: any[]) => any) | undefined;
                              onToggle?: ((...args: any[]) => any) | undefined;
                              'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                              onClear?: ((...args: any[]) => any) | undefined;
                              'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                              'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                          }>,
                      {
                          checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                          colorSchemeClass: ComputedRef<string>;
                          componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                          styleSetVariables: ComputedRef<Record<string, string>>;
                          componentInlineStyle: ComputedRef<CSSProperties>;
                          classObj: ComputedRef<{
                              'vs-checked': boolean;
                              'vs-disabled': boolean;
                              'vs-focus-visible': boolean;
                              'vs-indeterminate': boolean;
                              'vs-readonly': boolean;
                          }>;
                          sizeClass: ComputedRef<string>;
                          stateBoxClasses: ComputedRef<{}>;
                          computedId: ComputedRef<string>;
                          computedDisabled: ComputedRef<boolean>;
                          computedReadonly: ComputedRef<boolean>;
                          computedMessages: ComputedRef<StateMessage<UIState>[]>;
                          computedState: ComputedRef<UIState>;
                          convertToString: (value: any) => string;
                          inputValue: Ref<any, any>;
                          isChecked: ComputedRef<boolean>;
                          shake: Ref<boolean, boolean>;
                          toggle: (e: MouseEvent) => Promise<void>;
                          onFocus: (e: FocusEvent) => void;
                          onBlur: (e: FocusEvent) => void;
                          validate: () => boolean;
                          clear: () => void;
                          reset: () => void;
                          focus: () => void;
                          blur: () => void;
                      },
                      {},
                      {},
                      {},
                      ComponentOptionsMixin,
                      ComponentOptionsMixin,
                      (
                          | 'blur'
                          | 'change'
                          | 'focus'
                          | 'toggle'
                          | 'clear'
                          | 'update:modelValue'
                          | 'update:changed'
                          | 'update:valid'
                      )[],
                      PublicProps,
                      {
                          label: string;
                          messages: Message<any>[];
                          name: string;
                          noDefaultRules: boolean;
                          readonly: boolean;
                          rules: Rule<any>[];
                          state: UIState;
                          changed: boolean;
                          valid: boolean;
                          disabled: boolean;
                          hidden: boolean;
                          id: string;
                          noLabel: boolean;
                          noMessages: boolean;
                          required: boolean;
                          size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                          multiple: boolean;
                          modelValue: any;
                          beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                          checked: boolean;
                          checkLabel: string;
                          indeterminate: boolean;
                          trueValue: any;
                          falseValue: any;
                      },
                      true,
                      {},
                      {},
                      {
                          VsInputWrapper: DefineComponent<
                              ExtractPropTypes<{
                                  groupLabel: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  messages: {
                                      type: PropType<StateMessage<UIState>[]>;
                                      default: () => never[];
                                  };
                                  shake: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  styleSet: {
                                      type: PropType<string | VsInputWrapperStyleSet>;
                                  };
                                  disabled: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  hidden: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  id: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  label: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noLabel: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  noMessages: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  required: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  width: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  grid: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                              }>,
                              {
                                  needToShake: Ref<boolean, boolean>;
                                  componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                  componentInlineStyle: ComputedRef<CSSProperties>;
                              },
                              {},
                              {},
                              {},
                              ComponentOptionsMixin,
                              ComponentOptionsMixin,
                              {},
                              string,
                              PublicProps,
                              Readonly<
                                  ExtractPropTypes<{
                                      groupLabel: {
                                          type: BooleanConstructor;
                                          default: boolean;
                                      };
                                      messages: {
                                          type: PropType<StateMessage<UIState>[]>;
                                          default: () => never[];
                                      };
                                      shake: {
                                          type: BooleanConstructor;
                                          default: boolean;
                                      };
                                      styleSet: {
                                          type: PropType<string | VsInputWrapperStyleSet>;
                                      };
                                      disabled: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      hidden: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      id: {
                                          type: typeof String;
                                          default: string;
                                      };
                                      label: {
                                          type: typeof String;
                                          default: string;
                                      };
                                      noLabel: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      noMessages: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      required: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      width: {
                                          type: PropType<string | number | Breakpoints>;
                                      };
                                      grid: {
                                          type: PropType<string | number | Breakpoints>;
                                      };
                                  }>
                              > &
                                  Readonly<{}>,
                              {
                                  label: string;
                                  messages: StateMessage<UIState>[];
                                  disabled: boolean;
                                  hidden: boolean;
                                  id: string;
                                  noLabel: boolean;
                                  noMessages: boolean;
                                  required: boolean;
                                  groupLabel: boolean;
                                  shake: boolean;
                              },
                              {},
                              {
                                  VsResponsive: DefineComponent<
                                      ExtractPropTypes<{
                                          tag: {
                                              type: StringConstructor;
                                              default: string;
                                          };
                                          width: {
                                              type: PropType<string | number | Breakpoints>;
                                          };
                                          grid: {
                                              type: PropType<string | number | Breakpoints>;
                                          };
                                      }>,
                                      {
                                          responsiveClasses: ComputedRef<string[]>;
                                          responsiveStyles: ComputedRef<Record<string, string>>;
                                      },
                                      {},
                                      {},
                                      {},
                                      ComponentOptionsMixin,
                                      ComponentOptionsMixin,
                                      {},
                                      string,
                                      PublicProps,
                                      Readonly<
                                          ExtractPropTypes<{
                                              tag: {
                                                  type: StringConstructor;
                                                  default: string;
                                              };
                                              width: {
                                                  type: PropType<string | number | Breakpoints>;
                                              };
                                              grid: {
                                                  type: PropType<string | number | Breakpoints>;
                                              };
                                          }>
                                      > &
                                          Readonly<{}>,
                                      {
                                          tag: string;
                                      },
                                      {},
                                      {},
                                      {},
                                      string,
                                      ComponentProvideOptions,
                                      true,
                                      {},
                                      any
                                  >;
                                  VsMessage: DefineComponent<
                                      ExtractPropTypes<{
                                          state: {
                                              type: PropType<UIState>;
                                              default: string;
                                          };
                                          text: {
                                              type: StringConstructor;
                                              default: string;
                                          };
                                          styleSet: {
                                              type: PropType<string | VsMessageStyleSet>;
                                          };
                                      }>,
                                      {
                                          colorClass: ComputedRef<
                                              | 'vs-cs-blue'
                                              | 'vs-cs-green'
                                              | 'vs-cs-amber'
                                              | 'vs-cs-red'
                                              | 'vs-cs-default'
                                          >;
                                          icon: ComputedRef<Component>;
                                          styleSetVariables: ComputedRef<Record<string, string>>;
                                          componentInlineStyle: ComputedRef<CSSProperties>;
                                      },
                                      {},
                                      {},
                                      {},
                                      ComponentOptionsMixin,
                                      ComponentOptionsMixin,
                                      {},
                                      string,
                                      PublicProps,
                                      Readonly<
                                          ExtractPropTypes<{
                                              state: {
                                                  type: PropType<UIState>;
                                                  default: string;
                                              };
                                              text: {
                                                  type: StringConstructor;
                                                  default: string;
                                              };
                                              styleSet: {
                                                  type: PropType<string | VsMessageStyleSet>;
                                              };
                                          }>
                                      > &
                                          Readonly<{}>,
                                      {
                                          text: string;
                                          state: UIState;
                                      },
                                      {},
                                      {},
                                      {},
                                      string,
                                      ComponentProvideOptions,
                                      true,
                                      {},
                                      any
                                  >;
                              },
                              {},
                              string,
                              ComponentProvideOptions,
                              true,
                              {},
                              any
                          >;
                      } & GlobalComponents,
                      GlobalDirectives,
                      string,
                      {},
                      any,
                      ComponentProvideOptions,
                      {
                          P: {};
                          B: {};
                          D: {};
                          C: {};
                          M: {};
                          Defaults: {};
                      },
                      Readonly<
                          ExtractPropTypes<{
                              beforeChange: {
                                  type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                  default: null;
                              };
                              checked: {
                                  type: BooleanConstructor;
                                  default: boolean;
                              };
                              checkLabel: {
                                  type: StringConstructor;
                                  default: string;
                              };
                              indeterminate: {
                                  type: BooleanConstructor;
                                  default: boolean;
                              };
                              multiple: {
                                  type: BooleanConstructor;
                                  default: boolean;
                              };
                              size: {
                                  type: PropType<Size>;
                                  default: string;
                              };
                              trueValue: {
                                  type: null;
                                  default: boolean;
                              };
                              falseValue: {
                                  type: null;
                                  default: boolean;
                              };
                              modelValue: {
                                  type: null;
                                  default: boolean;
                              };
                              width: {
                                  type: PropType<string | number | Breakpoints>;
                              };
                              grid: {
                                  type: PropType<string | number | Breakpoints>;
                              };
                              label: {
                                  type: typeof String;
                                  default: string;
                              };
                              messages: {
                                  type: PropType<Message<any>[]>;
                                  default: () => Message<any>[];
                              };
                              name: {
                                  type: typeof String;
                                  default: string;
                              };
                              noDefaultRules: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              readonly: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              rules: {
                                  type: PropType<Rule<any>[]>;
                                  default: () => Rule<any>[];
                              };
                              state: {
                                  type: PropType<UIState>;
                                  default: UIState;
                              };
                              changed: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              valid: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              disabled: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              hidden: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              id: {
                                  type: typeof String;
                                  default: string;
                              };
                              noLabel: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              noMessages: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              required: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              styleSet: {
                                  type: PropType<string | VsCheckboxStyleSet>;
                              };
                              colorScheme: {
                                  type: PropType<ColorScheme>;
                              };
                          }>
                      > &
                          Readonly<{
                              onFocus?: ((...args: any[]) => any) | undefined;
                              onBlur?: ((...args: any[]) => any) | undefined;
                              onChange?: ((...args: any[]) => any) | undefined;
                              onToggle?: ((...args: any[]) => any) | undefined;
                              'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                              onClear?: ((...args: any[]) => any) | undefined;
                              'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                              'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                          }>,
                      {
                          checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                          colorSchemeClass: ComputedRef<string>;
                          componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                          styleSetVariables: ComputedRef<Record<string, string>>;
                          componentInlineStyle: ComputedRef<CSSProperties>;
                          classObj: ComputedRef<{
                              'vs-checked': boolean;
                              'vs-disabled': boolean;
                              'vs-focus-visible': boolean;
                              'vs-indeterminate': boolean;
                              'vs-readonly': boolean;
                          }>;
                          sizeClass: ComputedRef<string>;
                          stateBoxClasses: ComputedRef<{}>;
                          computedId: ComputedRef<string>;
                          computedDisabled: ComputedRef<boolean>;
                          computedReadonly: ComputedRef<boolean>;
                          computedMessages: ComputedRef<StateMessage<UIState>[]>;
                          computedState: ComputedRef<UIState>;
                          convertToString: (value: any) => string;
                          inputValue: Ref<any, any>;
                          isChecked: ComputedRef<boolean>;
                          shake: Ref<boolean, boolean>;
                          toggle: (e: MouseEvent) => Promise<void>;
                          onFocus: (e: FocusEvent) => void;
                          onBlur: (e: FocusEvent) => void;
                          validate: () => boolean;
                          clear: () => void;
                          reset: () => void;
                          focus: () => void;
                          blur: () => void;
                      },
                      {},
                      {},
                      {},
                      {
                          label: string;
                          messages: Message<any>[];
                          name: string;
                          noDefaultRules: boolean;
                          readonly: boolean;
                          rules: Rule<any>[];
                          state: UIState;
                          changed: boolean;
                          valid: boolean;
                          disabled: boolean;
                          hidden: boolean;
                          id: string;
                          noLabel: boolean;
                          noMessages: boolean;
                          required: boolean;
                          size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                          multiple: boolean;
                          modelValue: any;
                          beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                          checked: boolean;
                          checkLabel: string;
                          indeterminate: boolean;
                          trueValue: any;
                          falseValue: any;
                      }
                  >[]
                | null
            >
        >;
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsCheckboxSetStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            'vs-vertical': boolean;
            'vs-disabled': boolean;
            'vs-readonly': boolean;
        }>;
        sizeClass: ComputedRef<string>;
        computedId: ComputedRef<string>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        computedState: ComputedRef<UIState>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        checkboxStyleSet: ComputedRef<Omit<VsCheckboxStyleSet, '$wrapper'>>;
        shake: Ref<boolean, boolean>;
        inputValue: Ref<any[], any[]>;
        getOptionLabel: (option: any) => string;
        getOptionValue: (option: any) => any;
        onCheckboxUpdate: (value: any[]) => void;
        onFocus: (option: any, e: FocusEvent) => void;
        onBlur: (option: any, e: FocusEvent) => void;
        validate: () => boolean;
        clear: () => void;
        reset: () => void;
        focus: () => void;
        blur: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
    'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                default: null;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: PropType<any[]>;
                default: () => never[];
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            options: {
                type: PropType<any[]>;
                default: () => never[];
            };
            optionLabel: {
                type: StringConstructor;
                default: string;
            };
            optionValue: {
                type: StringConstructor;
                default: string;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any[]>[]>;
                default: () => Message<any[]>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any[]>[]>;
                default: () => Rule<any[]>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsCheckboxSetStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        messages: Message<any[]>[];
        name: string;
        noDefaultRules: boolean;
        readonly: boolean;
        rules: Rule<any[]>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        min: string | number;
        max: string | number;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        vertical: boolean;
        modelValue: any[];
        beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
        options: any[];
        optionLabel: string;
        optionValue: string;
    },
    {},
    {
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsCheckbox: DefineComponent<
            ExtractPropTypes<{
                beforeChange: {
                    type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                    default: null;
                };
                checked: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                checkLabel: {
                    type: StringConstructor;
                    default: string;
                };
                indeterminate: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                trueValue: {
                    type: null;
                    default: boolean;
                };
                falseValue: {
                    type: null;
                    default: boolean;
                };
                modelValue: {
                    type: null;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<any>[]>;
                    default: () => Message<any>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<any>[]>;
                    default: () => Rule<any>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsCheckboxStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    'vs-checked': boolean;
                    'vs-disabled': boolean;
                    'vs-focus-visible': boolean;
                    'vs-indeterminate': boolean;
                    'vs-readonly': boolean;
                }>;
                sizeClass: ComputedRef<string>;
                stateBoxClasses: ComputedRef<{}>;
                computedId: ComputedRef<string>;
                computedDisabled: ComputedRef<boolean>;
                computedReadonly: ComputedRef<boolean>;
                computedMessages: ComputedRef<StateMessage<UIState>[]>;
                computedState: ComputedRef<UIState>;
                convertToString: (value: any) => string;
                inputValue: Ref<any, any>;
                isChecked: ComputedRef<boolean>;
                shake: Ref<boolean, boolean>;
                toggle: (e: MouseEvent) => Promise<void>;
                onFocus: (e: FocusEvent) => void;
                onBlur: (e: FocusEvent) => void;
                validate: () => boolean;
                clear: () => void;
                reset: () => void;
                focus: () => void;
                blur: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            (
                | 'blur'
                | 'change'
                | 'focus'
                | 'toggle'
                | 'clear'
                | 'update:modelValue'
                | 'update:changed'
                | 'update:valid'
            )[],
            'blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    beforeChange: {
                        type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                        default: null;
                    };
                    checked: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    checkLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    indeterminate: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    multiple: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    trueValue: {
                        type: null;
                        default: boolean;
                    };
                    falseValue: {
                        type: null;
                        default: boolean;
                    };
                    modelValue: {
                        type: null;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<any>[]>;
                        default: () => Message<any>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<any>[]>;
                        default: () => Rule<any>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsCheckboxStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    onToggle?: ((...args: any[]) => any) | undefined;
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    onClear?: ((...args: any[]) => any) | undefined;
                    'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                    'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                label: string;
                messages: Message<any>[];
                name: string;
                noDefaultRules: boolean;
                readonly: boolean;
                rules: Rule<any>[];
                state: UIState;
                changed: boolean;
                valid: boolean;
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                multiple: boolean;
                modelValue: any;
                beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                checked: boolean;
                checkLabel: string;
                indeterminate: boolean;
                trueValue: any;
                falseValue: any;
            },
            {},
            {
                VsInputWrapper: DefineComponent<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        needToShake: Ref<boolean, boolean>;
                        componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        label: string;
                        messages: StateMessage<UIState>[];
                        disabled: boolean;
                        hidden: boolean;
                        id: string;
                        noLabel: boolean;
                        noMessages: boolean;
                        required: boolean;
                        groupLabel: boolean;
                        shake: boolean;
                    },
                    {},
                    {
                        VsResponsive: DefineComponent<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>,
                            {
                                responsiveClasses: ComputedRef<string[]>;
                                responsiveStyles: ComputedRef<Record<string, string>>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                tag: string;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsMessage: DefineComponent<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>,
                            {
                                colorClass: ComputedRef<
                                    'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                >;
                                icon: ComputedRef<Component>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                text: string;
                                state: UIState;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsCheckboxSetRef
    extends ComponentPublicInstance<typeof VsCheckboxSet>, FocusableRef, FormChildRef {}

export declare interface VsCheckboxSetStyleSet extends CSSProperties {
    $checkbox?: Omit<VsCheckboxStyleSet, '$wrapper'>;
    $wrapper?: VsInputWrapperStyleSet;
}

export declare interface VsCheckboxStyleSet extends CSSProperties {
    $checkboxCheckedColor?: string;
    $checkboxColor?: string;
    $checkboxSize?: string;
    $checkbox?: CSSProperties;
    $checkboxLabel?: CSSProperties;
    $wrapper?: VsInputWrapperStyleSet;
}

export declare const VsChip: DefineComponent<
    ExtractPropTypes<{
        closable: {
            type: BooleanConstructor;
            default: boolean;
        };
        outline: {
            type: BooleanConstructor;
            default: boolean;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsChipStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsChipStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            [x: string]: boolean;
            'vs-outline': boolean;
            'vs-primary': boolean;
        }>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'close'[],
    'close',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            closable: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsChipStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onClose?: ((...args: any[]) => any) | undefined;
        }>,
    {
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        outline: boolean;
        primary: boolean;
        closable: boolean;
    },
    {},
    {
        XIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsChipRef extends ComponentPublicInstance<typeof VsChip> {}

export declare interface VsChipStyleSet extends CSSProperties {
    $height?: string;
    $icon?: CSSProperties;
    $closeButton?: CSSProperties;
}

export declare enum VsComponent {
    VsAccordion = 'VsAccordion',
    VsAlert = 'VsAlert',
    VsAvatar = 'VsAvatar',
    VsBar = 'VsBar',
    VsBlock = 'VsBlock',
    VsButton = 'VsButton',
    VsCheckbox = 'VsCheckbox',
    VsCheckboxSet = 'VsCheckboxSet',
    VsChip = 'VsChip',
    VsConfirm = 'VsConfirm',
    VsContainer = 'VsContainer',
    VsDatePicker = 'VsDatePicker',
    VsDimmed = 'VsDimmed',
    VsDivider = 'VsDivider',
    VsDrawer = 'VsDrawer',
    VsExpandable = 'VsExpandable',
    VsFileDrop = 'VsFileDrop',
    VsFloating = 'VsFloating',
    VsFocusTrap = 'VsFocusTrap',
    VsFooter = 'VsFooter',
    VsForm = 'VsForm',
    VsGrid = 'VsGrid',
    VsHeader = 'VsHeader',
    VsImage = 'VsImage',
    VsIndexView = 'VsIndexView',
    VsInnerScroll = 'VsInnerScroll',
    VsInput = 'VsInput',
    VsInputWrapper = 'VsInputWrapper',
    VsLabelValue = 'VsLabelValue',
    VsLayout = 'VsLayout',
    VsLoading = 'VsLoading',
    VsMessage = 'VsMessage',
    VsModal = 'VsModal',
    VsModalNode = 'VsModalNode',
    VsModalView = 'VsModalView',
    VsGroupedList = 'VsGroupedList',
    VsPage = 'VsPage',
    VsPagination = 'VsPagination',
    VsProgress = 'VsProgress',
    VsPrompt = 'VsPrompt',
    VsRadio = 'VsRadio',
    VsRadioSet = 'VsRadioSet',
    VsRender = 'VsRender',
    VsResponsive = 'VsResponsive',
    VsSearchInput = 'VsSearchInput',
    VsSelect = 'VsSelect',
    VsSkeleton = 'VsSkeleton',
    VsSteps = 'VsSteps',
    VsSwitch = 'VsSwitch',
    VsTable = 'VsTable',
    VsTabs = 'VsTabs',
    VsTextarea = 'VsTextarea',
    VsTextWrap = 'VsTextWrap',
    VsThemeButton = 'VsThemeButton',
    VsToast = 'VsToast',
    VsToastView = 'VsToastView',
    VsToggle = 'VsToggle',
    VsTooltip = 'VsTooltip',
    VsVisibleRender = 'VsVisibleRender',
}

declare type VsComponentRegistry = typeof VlossomComponents;

declare interface VsConfirmStyleSet extends VsModalNodeStyleSet {
    $buttons?: CSSProperties;
    $okButton?: Omit<VsButtonStyleSet, '$loading'>;
    $cancelButton?: Omit<VsButtonStyleSet, '$loading'>;
}

export declare const VsContainer: DefineComponent<
    ExtractPropTypes<{
        tag: {
            type: StringConstructor;
            default: string;
        };
        layout: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>,
    {
        layoutStyles: ComputedRef<{}>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            tag: {
                type: StringConstructor;
                default: string;
            };
            layout: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>
    > &
        Readonly<{}>,
    {
        layout: boolean;
        tag: string;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsContainerRef extends ComponentPublicInstance<typeof VsContainer> {}

export declare const VsDatePicker: DefineComponent<
    ExtractPropTypes<{
        min: {
            type: StringConstructor;
            validator: (value: string, props: any) => boolean;
        };
        max: {
            type: StringConstructor;
            validator: (value: string, props: any) => boolean;
        };
        type: {
            type: PropType<VsDatePickerType>;
            default: string;
        };
        noClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        modelValue: {
            type: PropType<VsDatePickerValueType>;
            default: string;
            validator: (value: string, props: any) => boolean;
        };
        styleSet: {
            type: PropType<string | VsDatePickerStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<string>[]>;
            default: () => Message<string>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        placeholder: {
            type: typeof String;
            default: string;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<string>[]>;
            default: () => Rule<string>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
    }>,
    {
        dateInputRef: Readonly<ShallowRef<VsInputRef | null>>;
        deceiveType: ComputedRef<VsInputType>;
        componentStyleSet: ComputedRef<Partial<VsDatePickerStyleSet>>;
        displayValue: ComputedRef<string>;
        computedPlaceholder: ComputedRef<string>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        computedState: ComputedRef<UIState>;
        computedIcon: ComputedRef<Component>;
        shake: Ref<boolean, boolean>;
        computedId: ComputedRef<string>;
        onDateInput: (value: string | number | null) => void;
        onPointerDown: () => void;
        onClick: () => void;
        onKeydownEnter: (e: KeyboardEvent) => void;
        onFocus: (e: FocusEvent) => void;
        onBlur: (e: FocusEvent) => void;
        focus: () => void;
        blur: () => void;
        clear: () => void;
        reset: () => void;
        validate: () => boolean;
        open: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('blur' | 'change' | 'focus' | 'invalid' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
    'blur' | 'change' | 'focus' | 'invalid' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            min: {
                type: StringConstructor;
                validator: (value: string, props: any) => boolean;
            };
            max: {
                type: StringConstructor;
                validator: (value: string, props: any) => boolean;
            };
            type: {
                type: PropType<VsDatePickerType>;
                default: string;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: PropType<VsDatePickerValueType>;
                default: string;
                validator: (value: string, props: any) => boolean;
            };
            styleSet: {
                type: PropType<string | VsDatePickerStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<string>[]>;
                default: () => Message<string>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<string>[]>;
                default: () => Rule<string>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            onInvalid?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        messages: Message<string>[];
        name: string;
        noDefaultRules: boolean;
        placeholder: string;
        readonly: boolean;
        rules: Rule<string>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        type: VsDatePickerType;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        modelValue: string;
        noClear: boolean;
    },
    {},
    {
        CalendarIcon: LucideIcon;
        ClockIcon: LucideIcon;
        VsInput: DefineComponent<
            ExtractPropTypes<{
                autocomplete: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                noClear: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<VsInputType>;
                    default: string;
                };
                modelValue: {
                    type: PropType<VsInputValueType>;
                    default: null;
                };
                modelModifiers: {
                    type: PropType<StringModifiers>;
                    default: () => {};
                };
                min: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                max: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<VsInputValueType>[]>;
                    default: () => Message<VsInputValueType>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                placeholder: {
                    type: typeof String;
                    default: string;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<VsInputValueType>[]>;
                    default: () => Rule<VsInputValueType>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
            }>,
            {
                inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                classObj: ComputedRef<{
                    [x: string]: boolean;
                    'vs-focus-visible': boolean;
                    'vs-focus-within': boolean;
                    'vs-disabled': boolean;
                    'vs-readonly': boolean;
                }>;
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                inputValue: Ref<VsInputValueType, VsInputValueType>;
                computedMessages: ComputedRef<StateMessage<UIState>[]>;
                computedDisabled: ComputedRef<boolean>;
                computedReadonly: ComputedRef<boolean>;
                renderClearButton: ComputedRef<boolean>;
                shake: Ref<boolean, boolean>;
                stateBoxClasses: ComputedRef<{}>;
                computedId: ComputedRef<string>;
                onInput: (event: Event) => void;
                focus: () => void;
                blur: () => void;
                select: () => void;
                clear: () => void;
                reset: () => void;
                onFocus: (e: FocusEvent) => void;
                onBlur: (e: FocusEvent) => void;
                validate: () => boolean;
                clearWithFocus: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
            'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    autocomplete: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    noClear: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<VsInputType>;
                        default: string;
                    };
                    modelValue: {
                        type: PropType<VsInputValueType>;
                        default: null;
                    };
                    modelModifiers: {
                        type: PropType<StringModifiers>;
                        default: () => {};
                    };
                    min: {
                        type: PropType<number | string>;
                        default: string | number;
                        validator: (value: number | string) => boolean;
                    };
                    max: {
                        type: PropType<number | string>;
                        default: string | number;
                        validator: (value: number | string) => boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<VsInputValueType>[]>;
                        default: () => Message<VsInputValueType>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    placeholder: {
                        type: typeof String;
                        default: string;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<VsInputValueType>[]>;
                        default: () => Rule<VsInputValueType>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                }>
            > &
                Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    onClear?: ((...args: any[]) => any) | undefined;
                    'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                    'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                label: string;
                messages: Message<VsInputValueType>[];
                name: string;
                noDefaultRules: boolean;
                placeholder: string;
                readonly: boolean;
                rules: Rule<VsInputValueType>[];
                state: UIState;
                changed: boolean;
                valid: boolean;
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                min: string | number;
                max: string | number;
                type: VsInputType;
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                modelValue: VsInputValueType;
                autocomplete: boolean;
                noClear: boolean;
                modelModifiers: StringModifiers;
            },
            {},
            {
                VsInputWrapper: DefineComponent<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        needToShake: Ref<boolean, boolean>;
                        componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        label: string;
                        messages: StateMessage<UIState>[];
                        disabled: boolean;
                        hidden: boolean;
                        id: string;
                        noLabel: boolean;
                        noMessages: boolean;
                        required: boolean;
                        groupLabel: boolean;
                        shake: boolean;
                    },
                    {},
                    {
                        VsResponsive: DefineComponent<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>,
                            {
                                responsiveClasses: ComputedRef<string[]>;
                                responsiveStyles: ComputedRef<Record<string, string>>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                tag: string;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsMessage: DefineComponent<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>,
                            {
                                colorClass: ComputedRef<
                                    'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                >;
                                icon: ComputedRef<Component>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                text: string;
                                state: UIState;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                XIcon: LucideIcon;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare type VsDatePickerFormat = 'YYYY-MM-DD' | 'YYYY-MM-DDTHH:mm' | 'HH:mm' | 'YYYY-MM';

export declare interface VsDatePickerRef
    extends ComponentPublicInstance<typeof VsDatePicker>, FocusableRef, FormChildRef {
    open: () => void;
}

export declare interface VsDatePickerStyleSet extends CSSProperties {
    $input?: VsInputStyleSet;
    $wrapper?: VsInputWrapperStyleSet;
}

export declare type VsDatePickerType = 'date' | 'datetime-local' | 'time' | 'month';

export declare type VsDatePickerValueType = string;

export declare const VsDimmed: DefineComponent<
    ExtractPropTypes<{
        modelValue: {
            type: BooleanConstructor;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsDimmedStyleSet>;
        };
    }>,
    {
        isShow: Ref<boolean, boolean>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        show: () => void;
        hide: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'update:modelValue'[],
    'update:modelValue',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsDimmedStyleSet>;
            };
        }>
    > &
        Readonly<{
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        modelValue: boolean;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsDimmedRef extends ComponentPublicInstance<typeof VsDimmed> {
    show: () => void;
    hide: () => void;
}

export declare interface VsDimmedStyleSet extends CSSProperties {}

export declare const VsDivider: DefineComponent<
    ExtractPropTypes<{
        responsive: {
            type: BooleanConstructor;
            default: boolean;
        };
        vertical: {
            type: BooleanConstructor;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsDividerStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            'vs-vertical': boolean;
            'vs-divider-responsive': boolean;
        }>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsDividerStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {
        vertical: boolean;
        responsive: boolean;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsDividerRef extends ComponentPublicInstance<typeof VsDivider> {}

export declare interface VsDividerStyleSet extends CSSProperties {
    $border?: string;
    $horizontalWidth?: string;
    $horizontalMargin?: string;
    $verticalHeight?: string;
    $verticalMargin?: string;
}

export declare const VsDrawer: DefineComponent<
    ExtractPropTypes<{
        fixed: {
            type: BooleanConstructor;
            default: boolean;
        };
        open: {
            type: BooleanConstructor;
            default: boolean;
        };
        pushContainer: {
            type: BooleanConstructor;
            default: boolean;
        };
        placement: {
            type: PropType<DrawerPlacement>;
            default: string;
        };
        size: {
            type: PropType<SizeProp>;
        };
        modelValue: {
            type: BooleanConstructor;
            default: boolean;
        };
        layout: {
            type: BooleanConstructor;
            default: boolean;
        };
        callbacks: {
            type: PropType<OverlayCallbacks>;
            default: () => {};
        };
        dimClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        dimmed: {
            type: BooleanConstructor;
            default: boolean;
        };
        escClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        focusLock: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideScroll: {
            type: BooleanConstructor;
            default: boolean;
        };
        id: {
            type: StringConstructor;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsDrawerStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        drawerRef: Readonly<ShallowRef<HTMLElement | null>>;
        focusTrapRef: Readonly<ShallowRef<FocusableRef | null>>;
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsDrawerStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        isOpen: Ref<boolean, boolean>;
        ANIMATION_DURATION: number;
        onClickDimmed: () => void;
        isDimmed: ComputedRef<boolean>;
        openDrawer: () => void;
        closeDrawer: () => void;
        layoutStyles: ComputedRef<{
            [key: string]: string;
        }>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('close' | 'open' | 'update:modelValue' | 'click-dimmed')[],
    'close' | 'open' | 'update:modelValue' | 'click-dimmed',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            fixed: {
                type: BooleanConstructor;
                default: boolean;
            };
            open: {
                type: BooleanConstructor;
                default: boolean;
            };
            pushContainer: {
                type: BooleanConstructor;
                default: boolean;
            };
            placement: {
                type: PropType<DrawerPlacement>;
                default: string;
            };
            size: {
                type: PropType<SizeProp>;
            };
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            layout: {
                type: BooleanConstructor;
                default: boolean;
            };
            callbacks: {
                type: PropType<OverlayCallbacks>;
                default: () => {};
            };
            dimClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            dimmed: {
                type: BooleanConstructor;
                default: boolean;
            };
            escClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            focusLock: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsDrawerStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClose?: ((...args: any[]) => any) | undefined;
            onOpen?: ((...args: any[]) => any) | undefined;
            'onClick-dimmed'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        id: string;
        fixed: boolean;
        open: boolean;
        layout: boolean;
        modelValue: boolean;
        hideScroll: boolean;
        pushContainer: boolean;
        placement: DrawerPlacement;
        callbacks: OverlayCallbacks;
        dimmed: boolean;
        dimClose: boolean;
        escClose: boolean;
        focusLock: boolean;
    },
    {},
    {
        VsDimmed: DefineComponent<
            ExtractPropTypes<{
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsDimmedStyleSet>;
                };
            }>,
            {
                isShow: Ref<boolean, boolean>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                show: () => void;
                hide: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            'update:modelValue'[],
            'update:modelValue',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsDimmedStyleSet>;
                    };
                }>
            > &
                Readonly<{
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                modelValue: boolean;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsFocusTrap: DefineComponent<
            ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>,
            () =>
                | VNode<
                      RendererNode,
                      RendererElement,
                      {
                          [key: string]: any;
                      }
                  >
                | VNode<
                      RendererNode,
                      RendererElement,
                      {
                          [key: string]: any;
                      }
                  >[]
                | null,
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>
            > &
                Readonly<{}>,
            {
                disabled: boolean;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsInnerScroll: DefineComponent<
            ExtractPropTypes<{
                hideScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInnerScrollStyleSet>;
                };
            }>,
            {
                componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                hasScroll: () => boolean;
                bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    hideScroll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInnerScrollStyleSet>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                hideScroll: boolean;
            },
            {},
            {},
            {
                scrollShadow: Directive<HTMLElement, boolean | undefined>;
            },
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsDrawerRef extends ComponentPublicInstance<typeof VsDrawer> {
    openDrawer: () => void;
    closeDrawer: () => void;
}

export declare interface VsDrawerStyleSet extends CSSProperties {
    $size?: string;
    $dimmed?: VsDimmedStyleSet;
    $header?: CSSProperties;
    $content?: CSSProperties;
    $footer?: CSSProperties;
}

export declare const VsExpandable: DefineComponent<
    ExtractPropTypes<{
        open: {
            type: BooleanConstructor;
            required: true;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsExpandableStyleSet>;
        };
    }>,
    {
        sizeClass: ComputedRef<string>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        beforeEnter: (el: Element) => void;
        enter: (el: Element, done: () => void) => void;
        beforeLeave: (el: Element) => void;
        leave: (el: Element, done: () => void) => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            open: {
                type: BooleanConstructor;
                required: true;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsExpandableStyleSet>;
            };
        }>
    > &
        Readonly<{}>,
    {
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsExpandableRef extends ComponentPublicInstance<typeof VsExpandable> {}

export declare interface VsExpandableStyleSet extends CSSProperties {}

export declare const VsFileDrop: DefineComponent<
    ExtractPropTypes<{
        accept: {
            type: StringConstructor;
            default: string;
        };
        height: {
            type: PropType<string | number | Breakpoints>;
            default: string;
        };
        noClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: PropType<FileDropValueType>;
            default: () => never[];
        };
        min: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        max: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        styleSet: {
            type: PropType<string | VsFileDropStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<FileDropValueType>[]>;
            default: () => Message<FileDropValueType>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        placeholder: {
            type: typeof String;
            default: string;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<FileDropValueType>[]>;
            default: () => Rule<FileDropValueType>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
    }>,
    {
        fileDropRef: Readonly<ShallowRef<HTMLInputElement | null>>;
        computedId: ComputedRef<string>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        shake: Ref<boolean, boolean>;
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsFileDropStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            'vs-focus-visible': boolean;
            'vs-focus-within': boolean;
            'vs-disabled': boolean;
            'vs-readonly': boolean;
            'vs-dragging': boolean;
        }>;
        stateBoxClasses: ComputedRef<{}>;
        dragging: Ref<boolean, boolean>;
        inputValue: Ref<FileDropValueType, FileDropValueType>;
        hasValue: ComputedRef<boolean>;
        stringUtil: {
            createID(size?: number): string;
            convertToString(value: any): string;
            toStringSize(value: number | string): string;
            toFileSizeFormat(bytes: number): string;
            hash(str: string): string;
            kebabCase: kebabCase;
        };
        setDragging: (value: boolean) => void;
        openFileDialog: () => void;
        handleFileDialog: (event: Event) => void;
        handleFileDrop: (event: DragEvent) => void;
        handleFileRemove: (target: File) => void;
        onFocus: (e: FocusEvent) => void;
        onBlur: (e: FocusEvent) => void;
        focus: () => void;
        blur: () => void;
        validate: () => boolean;
        clear: () => void;
        reset: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('blur' | 'change' | 'drop' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
    'blur' | 'change' | 'drop' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            accept: {
                type: StringConstructor;
                default: string;
            };
            height: {
                type: PropType<string | number | Breakpoints>;
                default: string;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: PropType<FileDropValueType>;
                default: () => never[];
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            styleSet: {
                type: PropType<string | VsFileDropStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<FileDropValueType>[]>;
                default: () => Message<FileDropValueType>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<FileDropValueType>[]>;
                default: () => Rule<FileDropValueType>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>
    > &
        Readonly<{
            onDrop?: ((...args: any[]) => any) | undefined;
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        messages: Message<FileDropValueType>[];
        name: string;
        noDefaultRules: boolean;
        placeholder: string;
        readonly: boolean;
        rules: Rule<FileDropValueType>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        min: string | number;
        max: string | number;
        height: string | number | Breakpoints;
        multiple: boolean;
        modelValue: FileDropValueType;
        noClear: boolean;
        accept: string;
    },
    {},
    {
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsChip: DefineComponent<
            ExtractPropTypes<{
                closable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsChipStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsChipStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    [x: string]: boolean;
                    'vs-outline': boolean;
                    'vs-primary': boolean;
                }>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            'close'[],
            'close',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    closable: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsChipStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    onClose?: ((...args: any[]) => any) | undefined;
                }>,
            {
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                outline: boolean;
                primary: boolean;
                closable: boolean;
            },
            {},
            {
                XIcon: LucideIcon;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        PaperclipIcon: LucideIcon;
        XIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsFileDropRef extends ComponentPublicInstance<typeof VsFileDrop>, FocusableRef, FormChildRef {}

export declare interface VsFileDropStyleSet extends CSSProperties {
    $dragBackgroundColor?: string;
    $iconColor?: string;
    $placeholder?: CSSProperties;
    $files?: CSSProperties;
    $closeButton?: CSSProperties;
    $chip?: VsChipStyleSet;
    $wrapper?: VsInputWrapperStyleSet;
}

export declare const VsFloating: DefineComponent<
    ExtractPropTypes<{
        followWidth: {
            type: BooleanConstructor;
            default: boolean;
        };
        overlayId: {
            type: StringConstructor;
            default: string;
        };
        modelValue: {
            type: BooleanConstructor;
            default: boolean;
        };
        target: {
            type: StringConstructor;
            required: boolean;
            default: string;
        };
        align: {
            type: PropType<Alignment>;
            default: 'start' | 'center' | 'end';
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        enterDelay: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        leaveDelay: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        margin: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        noAnimation: {
            type: BooleanConstructor;
            default: boolean;
        };
        placement: {
            type: PropType<Placement>;
            default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
        };
    }>,
    {
        floatingRef: Readonly<ShallowRef<HTMLElement | null>>;
        computedPlacement: Ref<
            'top' | 'right' | 'bottom' | 'left' | 'middle' | null,
            'top' | 'right' | 'bottom' | 'left' | 'middle' | null
        >;
        isVisible: Ref<boolean, boolean>;
        isFloated: Ref<boolean, boolean>;
        animationClass: ComputedRef<string | null>;
        floatingStyle: ComputedRef<
            | {
                  animationDelay?: undefined;
              }
            | {
                  animationDelay: string;
              }
        >;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'update:modelValue'[],
    'update:modelValue',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            followWidth: {
                type: BooleanConstructor;
                default: boolean;
            };
            overlayId: {
                type: StringConstructor;
                default: string;
            };
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            target: {
                type: StringConstructor;
                required: boolean;
                default: string;
            };
            align: {
                type: PropType<Alignment>;
                default: 'start' | 'center' | 'end';
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            enterDelay: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            leaveDelay: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            margin: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            noAnimation: {
                type: BooleanConstructor;
                default: boolean;
            };
            placement: {
                type: PropType<Placement>;
                default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
            };
        }>
    > &
        Readonly<{
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        disabled: boolean;
        margin: string | number;
        modelValue: boolean;
        target: string;
        placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
        overlayId: string;
        followWidth: boolean;
        align: 'start' | 'center' | 'end';
        enterDelay: string | number;
        leaveDelay: string | number;
        noAnimation: boolean;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsFloatingRef extends ComponentPublicInstance<typeof VsFloating> {}

export declare const VsFocusTrap: DefineComponent<
    ExtractPropTypes<{
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>,
    () =>
        | VNode<
              RendererNode,
              RendererElement,
              {
                  [key: string]: any;
              }
          >
        | VNode<
              RendererNode,
              RendererElement,
              {
                  [key: string]: any;
              }
          >[]
        | null,
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>
    > &
        Readonly<{}>,
    {
        disabled: boolean;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsFocusTrapRef extends ComponentPublicInstance<typeof VsFocusTrap>, FocusableRef {}

export declare const VsFooter: DefineComponent<
    ExtractPropTypes<{
        height: {
            type: StringConstructor;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        layout: {
            type: BooleanConstructor;
            default: boolean;
        };
        position: {
            type: PropType<CssPosition>;
        };
        styleSet: {
            type: PropType<string | VsFooterStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsFooterStyleSet>>;
        classObj: ComputedRef<{
            'vs-primary': boolean;
        }>;
        isLayoutChild: ComputedRef<boolean>;
        position: Ref<CssPosition | undefined, CssPosition | undefined>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            height: {
                type: StringConstructor;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            layout: {
                type: BooleanConstructor;
                default: boolean;
            };
            position: {
                type: PropType<CssPosition>;
            };
            styleSet: {
                type: PropType<string | VsFooterStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {
        layout: boolean;
        tag: string;
        primary: boolean;
    },
    {},
    {
        VsBar: DefineComponent<
            ExtractPropTypes<{
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                position: {
                    type: PropType<CssPosition>;
                };
                styleSet: {
                    type: PropType<string | VsBarStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    'vs-primary': boolean;
                }>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    position: {
                        type: PropType<CssPosition>;
                    };
                    styleSet: {
                        type: PropType<string | VsBarStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
                primary: boolean;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsFooterRef extends ComponentPublicInstance<typeof VsFooter> {}

export declare interface VsFooterStyleSet extends VsBarStyleSet {}

export declare const VsForm: DefineComponent<
    ExtractPropTypes<{
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        gridSize: {
            type: (StringConstructor | NumberConstructor)[];
        };
        columnGap: {
            type: (StringConstructor | NumberConstructor)[];
        };
        rowGap: {
            type: (StringConstructor | NumberConstructor)[];
        };
    }>,
    {
        valid: ComputedRef<boolean>;
        changed: ComputedRef<boolean>;
        validate: () => Promise<boolean>;
        clear: () => void;
        reset: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'error'[],
    'error',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            gridSize: {
                type: (StringConstructor | NumberConstructor)[];
            };
            columnGap: {
                type: (StringConstructor | NumberConstructor)[];
            };
            rowGap: {
                type: (StringConstructor | NumberConstructor)[];
            };
        }>
    > &
        Readonly<{
            onError?: ((...args: any[]) => any) | undefined;
        }>,
    {
        readonly: boolean;
        disabled: boolean;
    },
    {},
    {
        VsGrid: DefineComponent<
            ExtractPropTypes<{
                width: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsGridStyleSet>;
                };
                gridSize: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                columnGap: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                rowGap: {
                    type: (StringConstructor | NumberConstructor)[];
                };
            }>,
            {
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    width: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsGridStyleSet>;
                    };
                    gridSize: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    columnGap: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    rowGap: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsFormRef extends ComponentPublicInstance<typeof VsForm> {
    valid: ComputedRef<boolean>;
    changed: ComputedRef<boolean>;
    clear: () => void;
    validate: () => Promise<boolean>;
}

export declare const VsGrid: DefineComponent<
    ExtractPropTypes<{
        width: {
            type: (StringConstructor | NumberConstructor)[];
        };
        height: {
            type: (StringConstructor | NumberConstructor)[];
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsGridStyleSet>;
        };
        gridSize: {
            type: (StringConstructor | NumberConstructor)[];
        };
        columnGap: {
            type: (StringConstructor | NumberConstructor)[];
        };
        rowGap: {
            type: (StringConstructor | NumberConstructor)[];
        };
    }>,
    {
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            width: {
                type: (StringConstructor | NumberConstructor)[];
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsGridStyleSet>;
            };
            gridSize: {
                type: (StringConstructor | NumberConstructor)[];
            };
            columnGap: {
                type: (StringConstructor | NumberConstructor)[];
            };
            rowGap: {
                type: (StringConstructor | NumberConstructor)[];
            };
        }>
    > &
        Readonly<{}>,
    {
        tag: string;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsGridRef extends ComponentPublicInstance<typeof VsGrid> {}

export declare interface VsGridStyleSet extends CSSProperties {
    $gridSize?: number;
}

export declare const VsGroupedList: DefineComponent<
    ExtractPropTypes<{
        items: {
            type: PropType<OptionItem[]>;
            default: () => never[];
        };
        groupBy: {
            type: PropType<(option: any, index: number) => string | null> | null;
            default: null;
        };
        groupOrder: {
            type: PropType<string[]>;
            default: () => never[];
        };
        styleSet: {
            type: PropType<string | VsGroupedListStyleSet>;
        };
    }>,
    {
        visibleRenderRef: Readonly<ShallowRef<VsVisibleRenderRef | null>>;
        innerScrollRef: Readonly<ShallowRef<VsInnerScrollRef | null>>;
        componentStyleSet: ComputedRef<Partial<VsGroupedListStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        groupedItems: ComputedRef<VsGroupedListGroup[]>;
        emitClickItem: (item: OptionItem, groupedIndex: number, group: VsGroupedListGroup, groupIndex: number) => void;
        scrollToItem: (id: string) => void;
        hasScroll: () => boolean;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'click-item'[],
    'click-item',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            items: {
                type: PropType<OptionItem[]>;
                default: () => never[];
            };
            groupBy: {
                type: PropType<(option: any, index: number) => string | null> | null;
                default: null;
            };
            groupOrder: {
                type: PropType<string[]>;
                default: () => never[];
            };
            styleSet: {
                type: PropType<string | VsGroupedListStyleSet>;
            };
        }>
    > &
        Readonly<{
            'onClick-item'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        items: OptionItem[];
        groupBy: (option: any, index: number) => string | null;
        groupOrder: string[];
    },
    {},
    {
        VsInnerScroll: DefineComponent<
            ExtractPropTypes<{
                hideScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInnerScrollStyleSet>;
                };
            }>,
            {
                componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                hasScroll: () => boolean;
                bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    hideScroll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInnerScrollStyleSet>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                hideScroll: boolean;
            },
            {},
            {},
            {
                scrollShadow: Directive<HTMLElement, boolean | undefined>;
            },
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsVisibleRender: DefineComponent<
            ExtractPropTypes<{
                selector: {
                    type: StringConstructor;
                    default: null;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                rootMargin: {
                    type: StringConstructor;
                    default: string;
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                threshold: {
                    type: NumberConstructor;
                    default: number;
                    validator: (value: number) => boolean;
                };
            }>,
            {
                containerStyle: ComputedRef<
                    | {
                          height?: undefined;
                          overflowY?: undefined;
                      }
                    | {
                          height: string;
                          overflowY: string;
                      }
                >;
                scrollToElement: (element: HTMLElement) => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    selector: {
                        type: StringConstructor;
                        default: null;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    rootMargin: {
                        type: StringConstructor;
                        default: string;
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    threshold: {
                        type: NumberConstructor;
                        default: number;
                        validator: (value: number) => boolean;
                    };
                }>
            > &
                Readonly<{}>,
            {
                disabled: boolean;
                tag: string;
                selector: string;
                rootMargin: string;
                threshold: number;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsGroupedListGroup {
    name: string;
    items: OptionItem[];
}

export declare interface VsGroupedListRef extends ComponentPublicInstance<typeof VsGroupedList> {
    scrollToItem: (id: string) => void;
    hasScroll: () => boolean;
}

export declare interface VsGroupedListStyleSet extends CSSProperties {
    $header?: CSSProperties;
    $content?: CSSProperties;
    $footer?: CSSProperties;
    $group?: CSSProperties;
    $item?: CSSProperties;
}

export declare const VsHeader: DefineComponent<
    ExtractPropTypes<{
        height: {
            type: StringConstructor;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        layout: {
            type: BooleanConstructor;
            default: boolean;
        };
        position: {
            type: PropType<CssPosition>;
        };
        styleSet: {
            type: PropType<string | VsHeaderStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsHeaderStyleSet>>;
        classObj: ComputedRef<{
            'vs-primary': boolean;
        }>;
        isLayoutChild: ComputedRef<boolean>;
        position: Ref<CssPosition | undefined, CssPosition | undefined>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            height: {
                type: StringConstructor;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            layout: {
                type: BooleanConstructor;
                default: boolean;
            };
            position: {
                type: PropType<CssPosition>;
            };
            styleSet: {
                type: PropType<string | VsHeaderStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {
        layout: boolean;
        tag: string;
        primary: boolean;
    },
    {},
    {
        VsBar: DefineComponent<
            ExtractPropTypes<{
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                position: {
                    type: PropType<CssPosition>;
                };
                styleSet: {
                    type: PropType<string | VsBarStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    'vs-primary': boolean;
                }>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    position: {
                        type: PropType<CssPosition>;
                    };
                    styleSet: {
                        type: PropType<string | VsBarStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
                primary: boolean;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsHeaderRef extends ComponentPublicInstance<typeof VsHeader> {}

export declare interface VsHeaderStyleSet extends VsBarStyleSet {}

export declare const VsImage: DefineComponent<
    ExtractPropTypes<{
        alt: {
            type: StringConstructor;
            default: string;
        };
        fallback: {
            type: StringConstructor;
            default: string;
        };
        height: {
            type: (StringConstructor | NumberConstructor)[];
        };
        lazy: {
            type: BooleanConstructor;
            default: boolean;
        };
        noSkeleton: {
            type: BooleanConstructor;
            default: boolean;
        };
        src: {
            type: StringConstructor;
            required: true;
            default: string;
        };
        width: {
            type: (StringConstructor | NumberConstructor)[];
        };
        styleSet: {
            type: PropType<string | VsImageStyleSet>;
        };
    }>,
    {
        componentStyleSet: ComputedRef<Partial<VsImageStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        computedSrc: ComputedRef<string>;
        vsImageRef: Ref<null, null>;
        isLoading: Ref<boolean, boolean>;
        isNoImage: Ref<boolean, boolean>;
        onImageLoad: () => void;
        onImageError: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'error'[],
    'error',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            alt: {
                type: StringConstructor;
                default: string;
            };
            fallback: {
                type: StringConstructor;
                default: string;
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            lazy: {
                type: BooleanConstructor;
                default: boolean;
            };
            noSkeleton: {
                type: BooleanConstructor;
                default: boolean;
            };
            src: {
                type: StringConstructor;
                required: true;
                default: string;
            };
            width: {
                type: (StringConstructor | NumberConstructor)[];
            };
            styleSet: {
                type: PropType<string | VsImageStyleSet>;
            };
        }>
    > &
        Readonly<{
            onError?: ((...args: any[]) => any) | undefined;
        }>,
    {
        alt: string;
        fallback: string;
        lazy: boolean;
        noSkeleton: boolean;
        src: string;
    },
    {},
    {
        VsSkeleton: DefineComponent<
            ExtractPropTypes<{
                styleSet: {
                    type: PropType<string | VsSkeletonStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsSkeletonStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    styleSet: {
                        type: PropType<string | VsSkeletonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{}>,
            {},
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        ImageOffIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsImageRef extends ComponentPublicInstance<typeof VsImage> {}

export declare interface VsImageStyleSet extends CSSProperties {
    $image?: CSSProperties;
    $skeleton?: VsSkeletonStyleSet;
}

export declare const VsIndexView: DefineComponent<
    ExtractPropTypes<{
        keepAlive: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: NumberConstructor;
            default: number;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
    }>,
    () => VNode<
        RendererNode,
        RendererElement,
        {
            [key: string]: any;
        }
    > | null,
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'update:modelValue'[],
    'update:modelValue',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            keepAlive: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: NumberConstructor;
                default: number;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>
    > &
        Readonly<{
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        modelValue: number;
        keepAlive: boolean;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsIndexViewRef extends ComponentPublicInstance<typeof VsIndexView> {
    updateIndex: (index: number) => void;
}

export declare const VsInnerScroll: DefineComponent<
    ExtractPropTypes<{
        hideScroll: {
            type: BooleanConstructor;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsInnerScrollStyleSet>;
        };
    }>,
    {
        componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        hasScroll: () => boolean;
        bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            hideScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsInnerScrollStyleSet>;
            };
        }>
    > &
        Readonly<{}>,
    {
        hideScroll: boolean;
    },
    {},
    {},
    {
        scrollShadow: Directive<HTMLElement, boolean | undefined>;
    },
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsInnerScrollRef extends ComponentPublicInstance<typeof VsInnerScroll> {
    hasScroll: () => boolean;
}

export declare interface VsInnerScrollStyleSet extends CSSProperties {
    $header?: CSSProperties;
    $content?: CSSProperties;
    $footer?: CSSProperties;
}

export declare const VsInput: DefineComponent<
    ExtractPropTypes<{
        autocomplete: {
            type: BooleanConstructor;
            default: boolean;
        };
        noClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        type: {
            type: PropType<VsInputType>;
            default: string;
        };
        modelValue: {
            type: PropType<VsInputValueType>;
            default: null;
        };
        modelModifiers: {
            type: PropType<StringModifiers>;
            default: () => {};
        };
        min: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        max: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        styleSet: {
            type: PropType<string | VsInputStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<VsInputValueType>[]>;
            default: () => Message<VsInputValueType>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        placeholder: {
            type: typeof String;
            default: string;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<VsInputValueType>[]>;
            default: () => Rule<VsInputValueType>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
    }>,
    {
        inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
        classObj: ComputedRef<{
            [x: string]: boolean;
            'vs-focus-visible': boolean;
            'vs-focus-within': boolean;
            'vs-disabled': boolean;
            'vs-readonly': boolean;
        }>;
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        inputValue: Ref<VsInputValueType, VsInputValueType>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        renderClearButton: ComputedRef<boolean>;
        shake: Ref<boolean, boolean>;
        stateBoxClasses: ComputedRef<{}>;
        computedId: ComputedRef<string>;
        onInput: (event: Event) => void;
        focus: () => void;
        blur: () => void;
        select: () => void;
        clear: () => void;
        reset: () => void;
        onFocus: (e: FocusEvent) => void;
        onBlur: (e: FocusEvent) => void;
        validate: () => boolean;
        clearWithFocus: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
    'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            autocomplete: {
                type: BooleanConstructor;
                default: boolean;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            type: {
                type: PropType<VsInputType>;
                default: string;
            };
            modelValue: {
                type: PropType<VsInputValueType>;
                default: null;
            };
            modelModifiers: {
                type: PropType<StringModifiers>;
                default: () => {};
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            styleSet: {
                type: PropType<string | VsInputStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<VsInputValueType>[]>;
                default: () => Message<VsInputValueType>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<VsInputValueType>[]>;
                default: () => Rule<VsInputValueType>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        messages: Message<VsInputValueType>[];
        name: string;
        noDefaultRules: boolean;
        placeholder: string;
        readonly: boolean;
        rules: Rule<VsInputValueType>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        min: string | number;
        max: string | number;
        type: VsInputType;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        modelValue: VsInputValueType;
        autocomplete: boolean;
        noClear: boolean;
        modelModifiers: StringModifiers;
    },
    {},
    {
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        XIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsInputRef extends ComponentPublicInstance<typeof VsInput>, FocusableRef, FormChildRef {
    select: () => void;
}

export declare interface VsInputStyleSet extends CSSProperties {
    $prepend?: CSSProperties;
    $append?: CSSProperties;
    $input?: CSSProperties;
    $wrapper?: VsInputWrapperStyleSet;
}

export declare type VsInputType = 'email' | 'number' | 'password' | 'search' | 'tel' | 'text' | 'url';

export declare type VsInputValueType = string | number | null;

export declare const VsInputWrapper: DefineComponent<
    ExtractPropTypes<{
        groupLabel: {
            type: BooleanConstructor;
            default: boolean;
        };
        messages: {
            type: PropType<StateMessage<UIState>[]>;
            default: () => never[];
        };
        shake: {
            type: BooleanConstructor;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsInputWrapperStyleSet>;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        label: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
    }>,
    {
        needToShake: Ref<boolean, boolean>;
        componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            groupLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            messages: {
                type: PropType<StateMessage<UIState>[]>;
                default: () => never[];
            };
            shake: {
                type: BooleanConstructor;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsInputWrapperStyleSet>;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            label: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>
    > &
        Readonly<{}>,
    {
        label: string;
        messages: StateMessage<UIState>[];
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        groupLabel: boolean;
        shake: boolean;
    },
    {},
    {
        VsResponsive: DefineComponent<
            ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                responsiveClasses: ComputedRef<string[]>;
                responsiveStyles: ComputedRef<Record<string, string>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsMessage: DefineComponent<
            ExtractPropTypes<{
                state: {
                    type: PropType<UIState>;
                    default: string;
                };
                text: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsMessageStyleSet>;
                };
            }>,
            {
                colorClass: ComputedRef<'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'>;
                icon: ComputedRef<Component>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    state: {
                        type: PropType<UIState>;
                        default: string;
                    };
                    text: {
                        type: StringConstructor;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsMessageStyleSet>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                text: string;
                state: UIState;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsInputWrapperRef extends ComponentPublicInstance<typeof VsInputWrapper> {}

export declare interface VsInputWrapperStyleSet extends CSSProperties {
    $label?: CSSProperties;
    $messages?: CSSProperties;
    $message?: VsMessageStyleSet;
}

export declare const VsLabelValue: DefineComponent<
    ExtractPropTypes<{
        size: {
            type: PropType<Size>;
            default: string;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        vertical: {
            type: BooleanConstructor;
            default: boolean;
        };
        responsive: {
            type: BooleanConstructor;
            default: boolean;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        styleSet: {
            type: PropType<string | VsLabelValueStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        classObj: ComputedRef<{
            [x: string]: boolean;
            'vs-primary': boolean;
            'vs-vertical': boolean;
            'vs-responsive-vertical': boolean;
        }>;
        colorSchemeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentStyleSet: ComputedRef<Partial<VsLabelValueStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            size: {
                type: PropType<Size>;
                default: string;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            styleSet: {
                type: PropType<string | VsLabelValueStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        vertical: boolean;
        primary: boolean;
        responsive: boolean;
    },
    {},
    {
        VsResponsive: DefineComponent<
            ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                responsiveClasses: ComputedRef<string[]>;
                responsiveStyles: ComputedRef<Record<string, string>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsLabelValueRef extends ComponentPublicInstance<typeof VsLabelValue> {}

export declare interface VsLabelValueStyleSet extends CSSProperties {
    $border?: string;
    $label?: CSSProperties;
    $value?: CSSProperties;
}

export declare const VsLayout: DefineComponent<
    {},
    {},
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<{}> & Readonly<{}>,
    {},
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsLayoutRef extends ComponentPublicInstance<typeof VsLayout> {}

export declare const VsLoading: DefineComponent<
    ExtractPropTypes<{
        width: {
            type: (StringConstructor | NumberConstructor)[];
        };
        height: {
            type: (StringConstructor | NumberConstructor)[];
        };
        styleSet: {
            type: PropType<string | VsLoadingStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            width: {
                type: (StringConstructor | NumberConstructor)[];
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            styleSet: {
                type: PropType<string | VsLoadingStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {},
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsLoadingRef extends ComponentPublicInstance<typeof VsLoading> {}

export declare interface VsLoadingStyleSet extends CSSProperties {
    $barColor?: string;
    $barWidth?: string;
}

export declare const VsMessage: DefineComponent<
    ExtractPropTypes<{
        state: {
            type: PropType<UIState>;
            default: string;
        };
        text: {
            type: StringConstructor;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsMessageStyleSet>;
        };
    }>,
    {
        colorClass: ComputedRef<'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'>;
        icon: ComputedRef<Component>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            state: {
                type: PropType<UIState>;
                default: string;
            };
            text: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsMessageStyleSet>;
            };
        }>
    > &
        Readonly<{}>,
    {
        text: string;
        state: UIState;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsMessageRef extends ComponentPublicInstance<typeof VsMessage> {}

export declare interface VsMessageStyleSet extends CSSProperties {
    $size?: string;
}

export declare const VsModal: DefineComponent<
    ExtractPropTypes<{
        beforeClose: {
            type: PropType<() => Promise<boolean> | boolean>;
            default: undefined;
        };
        container: {
            type: StringConstructor;
            default: string;
        };
        escClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        scrollLock: {
            type: PropType<boolean | string>;
            default: boolean;
        };
        size: {
            type: PropType<
                | SizeProp
                | {
                      width?: SizeProp;
                      height?: SizeProp;
                  }
            >;
        };
        modelValue: {
            type: BooleanConstructor;
            default: boolean;
        };
        callbacks: {
            type: PropType<OverlayCallbacks>;
            default: () => {};
        };
        dimClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        dimmed: {
            type: BooleanConstructor;
            default: boolean;
        };
        focusLock: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideScroll: {
            type: BooleanConstructor;
            default: boolean;
        };
        id: {
            type: StringConstructor;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsModalNodeStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    () => null,
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('close' | 'open' | 'update:modelValue')[],
    'close' | 'open' | 'update:modelValue',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            beforeClose: {
                type: PropType<() => Promise<boolean> | boolean>;
                default: undefined;
            };
            container: {
                type: StringConstructor;
                default: string;
            };
            escClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollLock: {
                type: PropType<boolean | string>;
                default: boolean;
            };
            size: {
                type: PropType<
                    | SizeProp
                    | {
                          width?: SizeProp;
                          height?: SizeProp;
                      }
                >;
            };
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            callbacks: {
                type: PropType<OverlayCallbacks>;
                default: () => {};
            };
            dimClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            dimmed: {
                type: BooleanConstructor;
                default: boolean;
            };
            focusLock: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsModalNodeStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClose?: ((...args: any[]) => any) | undefined;
            onOpen?: ((...args: any[]) => any) | undefined;
        }>,
    {
        id: string;
        container: string;
        modelValue: boolean;
        hideScroll: boolean;
        callbacks: OverlayCallbacks;
        dimmed: boolean;
        dimClose: boolean;
        escClose: boolean;
        focusLock: boolean;
        beforeClose: () => Promise<boolean> | boolean;
        scrollLock: string | boolean;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare const VsModalNode: DefineComponent<
    ExtractPropTypes<{
        beforeClose: {
            type: PropType<() => Promise<boolean> | boolean>;
            default: undefined;
        };
        container: {
            type: StringConstructor;
            default: string;
        };
        escClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        dimClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        scrollLock: {
            type: PropType<boolean | string>;
            default: boolean;
        };
        size: {
            type: PropType<
                | SizeProp
                | {
                      width?: SizeProp;
                      height?: SizeProp;
                  }
            >;
        };
        callbacks: {
            type: PropType<OverlayCallbacks>;
            default: () => {};
        };
        dimmed: {
            type: BooleanConstructor;
            default: boolean;
        };
        focusLock: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideScroll: {
            type: BooleanConstructor;
            default: boolean;
        };
        id: {
            type: StringConstructor;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsModalNodeStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsModalNodeStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        focusLock: Ref<boolean, boolean>;
        onClickDimmed: () => Promise<void>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('close' | 'click-dimmed')[],
    'close' | 'click-dimmed',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            beforeClose: {
                type: PropType<() => Promise<boolean> | boolean>;
                default: undefined;
            };
            container: {
                type: StringConstructor;
                default: string;
            };
            escClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            dimClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            scrollLock: {
                type: PropType<boolean | string>;
                default: boolean;
            };
            size: {
                type: PropType<
                    | SizeProp
                    | {
                          width?: SizeProp;
                          height?: SizeProp;
                      }
                >;
            };
            callbacks: {
                type: PropType<OverlayCallbacks>;
                default: () => {};
            };
            dimmed: {
                type: BooleanConstructor;
                default: boolean;
            };
            focusLock: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            id: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsModalNodeStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onClose?: ((...args: any[]) => any) | undefined;
            'onClick-dimmed'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        id: string;
        container: string;
        hideScroll: boolean;
        callbacks: OverlayCallbacks;
        dimmed: boolean;
        dimClose: boolean;
        escClose: boolean;
        focusLock: boolean;
        beforeClose: () => Promise<boolean> | boolean;
        scrollLock: string | boolean;
    },
    {},
    {
        VsDimmed: DefineComponent<
            ExtractPropTypes<{
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsDimmedStyleSet>;
                };
            }>,
            {
                isShow: Ref<boolean, boolean>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                show: () => void;
                hide: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            'update:modelValue'[],
            'update:modelValue',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsDimmedStyleSet>;
                    };
                }>
            > &
                Readonly<{
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                modelValue: boolean;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsFocusTrap: DefineComponent<
            ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>,
            () =>
                | VNode<
                      RendererNode,
                      RendererElement,
                      {
                          [key: string]: any;
                      }
                  >
                | VNode<
                      RendererNode,
                      RendererElement,
                      {
                          [key: string]: any;
                      }
                  >[]
                | null,
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>
            > &
                Readonly<{}>,
            {
                disabled: boolean;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsModalNodeRef extends ComponentPublicInstance<typeof VsModalNode> {}

export declare interface VsModalNodeStyleSet extends CSSProperties {
    $dimmed?: VsDimmedStyleSet;
}

export declare interface VsModalRef extends ComponentPublicInstance<typeof VsModal> {}

export declare const VsModalView: DefineComponent<
    ExtractPropTypes<{
        container: {
            type: StringConstructor;
            default: string;
        };
    }>,
    {
        modals: ComputedRef<ModalInfo[]>;
        isFixed: ComputedRef<boolean>;
        ANIMATION_DURATION: number;
        onClose: (id: string) => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            container: {
                type: StringConstructor;
                default: string;
            };
        }>
    > &
        Readonly<{}>,
    {
        container: string;
    },
    {},
    {
        VsModalNode: DefineComponent<
            ExtractPropTypes<{
                beforeClose: {
                    type: PropType<() => Promise<boolean> | boolean>;
                    default: undefined;
                };
                container: {
                    type: StringConstructor;
                    default: string;
                };
                escClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                dimClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                scrollLock: {
                    type: PropType<boolean | string>;
                    default: boolean;
                };
                size: {
                    type: PropType<
                        | SizeProp
                        | {
                              width?: SizeProp;
                              height?: SizeProp;
                          }
                    >;
                };
                callbacks: {
                    type: PropType<OverlayCallbacks>;
                    default: () => {};
                };
                dimmed: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                focusLock: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideScroll: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                id: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsModalNodeStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsModalNodeStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                focusLock: Ref<boolean, boolean>;
                onClickDimmed: () => Promise<void>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('close' | 'click-dimmed')[],
            'close' | 'click-dimmed',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    beforeClose: {
                        type: PropType<() => Promise<boolean> | boolean>;
                        default: undefined;
                    };
                    container: {
                        type: StringConstructor;
                        default: string;
                    };
                    escClose: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    dimClose: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    scrollLock: {
                        type: PropType<boolean | string>;
                        default: boolean;
                    };
                    size: {
                        type: PropType<
                            | SizeProp
                            | {
                                  width?: SizeProp;
                                  height?: SizeProp;
                              }
                        >;
                    };
                    callbacks: {
                        type: PropType<OverlayCallbacks>;
                        default: () => {};
                    };
                    dimmed: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    focusLock: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideScroll: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    id: {
                        type: StringConstructor;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsModalNodeStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    onClose?: ((...args: any[]) => any) | undefined;
                    'onClick-dimmed'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                id: string;
                container: string;
                hideScroll: boolean;
                callbacks: OverlayCallbacks;
                dimmed: boolean;
                dimClose: boolean;
                escClose: boolean;
                focusLock: boolean;
                beforeClose: () => Promise<boolean> | boolean;
                scrollLock: string | boolean;
            },
            {},
            {
                VsDimmed: DefineComponent<
                    ExtractPropTypes<{
                        modelValue: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsDimmedStyleSet>;
                        };
                    }>,
                    {
                        isShow: Ref<boolean, boolean>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                        show: () => void;
                        hide: () => void;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    'update:modelValue'[],
                    'update:modelValue',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            modelValue: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsDimmedStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{
                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        modelValue: boolean;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsFocusTrap: DefineComponent<
                    ExtractPropTypes<{
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>,
                    () =>
                        | VNode<
                              RendererNode,
                              RendererElement,
                              {
                                  [key: string]: any;
                              }
                          >
                        | VNode<
                              RendererNode,
                              RendererElement,
                              {
                                  [key: string]: any;
                              }
                          >[]
                        | null,
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        disabled: boolean;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsRender: DefineComponent<
            ExtractPropTypes<{
                content: {
                    type: PropType<string | Component>;
                    required: true;
                };
                componentProps: {
                    type: PropType<Record<string, any>>;
                    default: () => {};
                };
            }>,
            () => VNode<
                RendererNode,
                RendererElement,
                {
                    [key: string]: any;
                }
            >,
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    content: {
                        type: PropType<string | Component>;
                        required: true;
                    };
                    componentProps: {
                        type: PropType<Record<string, any>>;
                        default: () => {};
                    };
                }>
            > &
                Readonly<{}>,
            {
                componentProps: Record<string, any>;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsModalViewRef extends ComponentPublicInstance<typeof VsModalView> {}

export declare const VsPage: DefineComponent<
    ExtractPropTypes<{
        styleSet: {
            type: PropType<string | VsPageStyleSet>;
        };
    }>,
    {
        componentStyleSet: ComputedRef<Partial<VsPageStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            styleSet: {
                type: PropType<string | VsPageStyleSet>;
            };
        }>
    > &
        Readonly<{}>,
    {},
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsPageRef extends ComponentPublicInstance<typeof VsPage> {}

export declare interface VsPageStyleSet extends CSSProperties {
    $title?: CSSProperties;
    $description?: CSSProperties;
    $content?: CSSProperties;
}

export declare const VsPagination: DefineComponent<
    ExtractPropTypes<{
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        edgeButtons: {
            type: BooleanConstructor;
            default: boolean;
        };
        ghost: {
            type: BooleanConstructor;
            default: boolean;
        };
        length: {
            type: NumberConstructor;
            required: true;
            default: number;
            validator: (value: number) => boolean;
        };
        outline: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        showingLength: {
            type: NumberConstructor;
            default: number;
            validator: (value: number) => boolean;
        };
        modelValue: {
            type: NumberConstructor;
            default: number;
        };
        styleSet: {
            type: PropType<string | VsPaginationStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        computedColorScheme: ComputedRef<
            | 'brown'
            | 'red'
            | 'orange'
            | 'amber'
            | 'yellow'
            | 'lime'
            | 'green'
            | 'emerald'
            | 'teal'
            | 'cyan'
            | 'sky'
            | 'blue'
            | 'indigo'
            | 'violet'
            | 'purple'
            | 'fuchsia'
            | 'pink'
            | 'rose'
            | 'gray'
            | 'none'
            | undefined
        >;
        colorSchemeClass: ComputedRef<string>;
        sizeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsPaginationStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        selectedIndex: Ref<number, number>;
        pages: ComputedRef<number[]>;
        getPageButtonStyleSet: (page: number) => Omit<VsButtonStyleSet, '$loading'>;
        goFirst: () => void;
        goLast: () => void;
        goPrev: () => void;
        goNext: () => void;
        setPage: (page: number) => void;
        selectIndex: (index: number) => void;
        isFirstEdge: ComputedRef<boolean>;
        isLastEdge: ComputedRef<boolean>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('change' | 'update:modelValue')[],
    'change' | 'update:modelValue',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            edgeButtons: {
                type: BooleanConstructor;
                default: boolean;
            };
            ghost: {
                type: BooleanConstructor;
                default: boolean;
            };
            length: {
                type: NumberConstructor;
                required: true;
                default: number;
                validator: (value: number) => boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            showingLength: {
                type: NumberConstructor;
                default: number;
                validator: (value: number) => boolean;
            };
            modelValue: {
                type: NumberConstructor;
                default: number;
            };
            styleSet: {
                type: PropType<string | VsPaginationStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        disabled: boolean;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        length: number;
        outline: boolean;
        modelValue: number;
        ghost: boolean;
        edgeButtons: boolean;
        showingLength: number;
    },
    {},
    {
        VsButton: DefineComponent<
            ExtractPropTypes<{
                circle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<'button' | 'submit' | 'reset'>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsButtonStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    [x: string]: boolean;
                    'vs-focus-visible': boolean;
                    'vs-circle': boolean;
                    'vs-disabled': boolean;
                    'vs-ghost': boolean;
                    'vs-loading-state': boolean;
                    'vs-outline': boolean;
                    'vs-primary': boolean;
                    'vs-responsive': boolean;
                }>;
                buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsButtonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                circle: boolean;
                disabled: boolean;
                type: 'button' | 'reset' | 'submit';
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                outline: boolean;
                primary: boolean;
                ghost: boolean;
                loading: boolean;
                responsive: boolean;
            },
            {},
            {
                VsLoading: DefineComponent<
                    ExtractPropTypes<{
                        width: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        styleSet: {
                            type: PropType<string | VsLoadingStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {},
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        ChevronFirstIcon: LucideIcon;
        ChevronLastIcon: LucideIcon;
        ChevronLeftIcon: LucideIcon;
        ChevronRightIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsPaginationRef extends ComponentPublicInstance<typeof VsPagination> {
    goFirst: () => void;
    goLast: () => void;
    goPrev: () => void;
    goNext: () => void;
    setPage: (page: number) => void;
}

export declare interface VsPaginationStyleSet extends CSSProperties {
    $pageButton?: Omit<VsButtonStyleSet, '$loading'> & {
        $selected?: Omit<VsButtonStyleSet, '$loading'>;
    };
    $controlButton?: Omit<VsButtonStyleSet, '$loading'>;
}

export declare const VsProgress: DefineComponent<
    ExtractPropTypes<{
        max: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
            validator: (value: number | string) => boolean;
        };
        value: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
            validator: (value: number | string) => boolean;
        };
        label: {
            type: StringConstructor;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsProgressStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        computedValue: ComputedRef<number>;
        computedMax: ComputedRef<number>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            max: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
                validator: (value: number | string) => boolean;
            };
            value: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
                validator: (value: number | string) => boolean;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsProgressStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {
        label: string;
        max: string | number;
        value: string | number;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsProgressRef extends ComponentPublicInstance<typeof VsProgress> {}

export declare interface VsProgressStyleSet extends CSSProperties {
    $barBackgroundColor?: string;
    $barBorder?: string;
    $barBorderRadius?: string;
    $valueBackgroundColor?: string;
    $labelTextShadow?: string;
    $labelFontColor?: string;
}

declare interface VsPromptStyleSet extends VsModalNodeStyleSet {
    $input?: Omit<VsInputStyleSet, '$append' | '$prepend'>;
    $buttons?: CSSProperties;
    $okButton?: Omit<VsButtonStyleSet, '$loading'>;
    $cancelButton?: Omit<VsButtonStyleSet, '$loading'>;
}

export declare const VsRadio: DefineComponent<
    ExtractPropTypes<{
        beforeChange: {
            type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
            default: null;
        };
        checked: {
            type: BooleanConstructor;
            default: boolean;
        };
        radioLabel: {
            type: StringConstructor;
            default: string;
        };
        radioValue: {
            type: null;
            required: true;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        modelValue: {
            type: null;
            default: null;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<any>[]>;
            default: () => Message<any>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<any>[]>;
            default: () => Rule<any>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsRadioStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        computedId: ComputedRef<string>;
        radioRef: Readonly<ShallowRef<HTMLInputElement | null>>;
        isChecked: ComputedRef<boolean>;
        colorSchemeClass: ComputedRef<string>;
        computedState: ComputedRef<UIState>;
        componentStyleSet: ComputedRef<Partial<VsRadioStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        classObj: ComputedRef<{
            'vs-disabled': boolean;
            'vs-focus-visible': boolean;
            'vs-readonly': boolean;
        }>;
        sizeClass: ComputedRef<string>;
        stateBoxClasses: ComputedRef<{}>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        inputValue: Ref<any, any>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        shake: Ref<boolean, boolean>;
        validate: () => boolean;
        clear: () => void;
        reset: () => void;
        onToggle: (event: Event) => Promise<void>;
        onFocus: (e: FocusEvent) => void;
        onBlur: (e: FocusEvent) => void;
        focus: () => void;
        blur: () => void;
        convertToString: (value: any) => string;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
    'blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                default: null;
            };
            checked: {
                type: BooleanConstructor;
                default: boolean;
            };
            radioLabel: {
                type: StringConstructor;
                default: string;
            };
            radioValue: {
                type: null;
                required: true;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: null;
                default: null;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsRadioStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            onToggle?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        messages: Message<any>[];
        name: string;
        noDefaultRules: boolean;
        readonly: boolean;
        rules: Rule<any>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        modelValue: any;
        beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
        checked: boolean;
        radioLabel: string;
    },
    {},
    {
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsRadioRef extends ComponentPublicInstance<typeof VsRadio>, FocusableRef, FormChildRef {}

export declare const VsRadioSet: DefineComponent<
    ExtractPropTypes<{
        beforeChange: {
            type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
            default: null;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        vertical: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: null;
            default: null;
        };
        options: {
            type: PropType<any[]>;
            default: () => never[];
        };
        optionLabel: {
            type: StringConstructor;
            default: string;
        };
        optionValue: {
            type: StringConstructor;
            default: string;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<any>[]>;
            default: () => Message<any>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<any>[]>;
            default: () => Rule<any>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsRadioSetStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        hidden: Ref<boolean, boolean>;
        label: Ref<string, string>;
        width: Ref<string | number | Breakpoints | undefined, string | number | Breakpoints | undefined>;
        grid: Ref<string | number | Breakpoints | undefined, string | number | Breakpoints | undefined>;
        noMessages: Ref<boolean, boolean>;
        colorScheme: Ref<
            | 'brown'
            | 'red'
            | 'orange'
            | 'amber'
            | 'yellow'
            | 'lime'
            | 'green'
            | 'emerald'
            | 'teal'
            | 'cyan'
            | 'sky'
            | 'blue'
            | 'indigo'
            | 'violet'
            | 'purple'
            | 'fuchsia'
            | 'pink'
            | 'rose'
            | 'gray'
            | 'none'
            | undefined,
            | 'brown'
            | 'red'
            | 'orange'
            | 'amber'
            | 'yellow'
            | 'lime'
            | 'green'
            | 'emerald'
            | 'teal'
            | 'cyan'
            | 'sky'
            | 'blue'
            | 'indigo'
            | 'violet'
            | 'purple'
            | 'fuchsia'
            | 'pink'
            | 'rose'
            | 'gray'
            | 'none'
            | undefined
        >;
        options: Ref<any[], any[]>;
        required: Ref<boolean, boolean>;
        radioRefs: Readonly<
            ShallowRef<
                | CreateComponentPublicInstanceWithMixins<
                      Readonly<
                          ExtractPropTypes<{
                              beforeChange: {
                                  type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                  default: null;
                              };
                              checked: {
                                  type: BooleanConstructor;
                                  default: boolean;
                              };
                              radioLabel: {
                                  type: StringConstructor;
                                  default: string;
                              };
                              radioValue: {
                                  type: null;
                                  required: true;
                              };
                              size: {
                                  type: PropType<Size>;
                                  default: string;
                              };
                              modelValue: {
                                  type: null;
                                  default: null;
                              };
                              width: {
                                  type: PropType<string | number | Breakpoints>;
                              };
                              grid: {
                                  type: PropType<string | number | Breakpoints>;
                              };
                              label: {
                                  type: typeof String;
                                  default: string;
                              };
                              messages: {
                                  type: PropType<Message<any>[]>;
                                  default: () => Message<any>[];
                              };
                              name: {
                                  type: typeof String;
                                  default: string;
                              };
                              noDefaultRules: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              readonly: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              rules: {
                                  type: PropType<Rule<any>[]>;
                                  default: () => Rule<any>[];
                              };
                              state: {
                                  type: PropType<UIState>;
                                  default: UIState;
                              };
                              changed: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              valid: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              disabled: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              hidden: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              id: {
                                  type: typeof String;
                                  default: string;
                              };
                              noLabel: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              noMessages: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              required: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              styleSet: {
                                  type: PropType<string | VsRadioStyleSet>;
                              };
                              colorScheme: {
                                  type: PropType<ColorScheme>;
                              };
                          }>
                      > &
                          Readonly<{
                              onFocus?: ((...args: any[]) => any) | undefined;
                              onBlur?: ((...args: any[]) => any) | undefined;
                              onChange?: ((...args: any[]) => any) | undefined;
                              onToggle?: ((...args: any[]) => any) | undefined;
                              'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                              onClear?: ((...args: any[]) => any) | undefined;
                              'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                              'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                          }>,
                      {
                          computedId: ComputedRef<string>;
                          radioRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                          isChecked: ComputedRef<boolean>;
                          colorSchemeClass: ComputedRef<string>;
                          computedState: ComputedRef<UIState>;
                          componentStyleSet: ComputedRef<Partial<VsRadioStyleSet>>;
                          styleSetVariables: ComputedRef<Record<string, string>>;
                          classObj: ComputedRef<{
                              'vs-disabled': boolean;
                              'vs-focus-visible': boolean;
                              'vs-readonly': boolean;
                          }>;
                          sizeClass: ComputedRef<string>;
                          stateBoxClasses: ComputedRef<{}>;
                          computedDisabled: ComputedRef<boolean>;
                          computedReadonly: ComputedRef<boolean>;
                          inputValue: Ref<any, any>;
                          computedMessages: ComputedRef<StateMessage<UIState>[]>;
                          shake: Ref<boolean, boolean>;
                          validate: () => boolean;
                          clear: () => void;
                          reset: () => void;
                          onToggle: (event: Event) => Promise<void>;
                          onFocus: (e: FocusEvent) => void;
                          onBlur: (e: FocusEvent) => void;
                          focus: () => void;
                          blur: () => void;
                          convertToString: (value: any) => string;
                      },
                      {},
                      {},
                      {},
                      ComponentOptionsMixin,
                      ComponentOptionsMixin,
                      (
                          | 'blur'
                          | 'change'
                          | 'focus'
                          | 'toggle'
                          | 'clear'
                          | 'update:modelValue'
                          | 'update:changed'
                          | 'update:valid'
                      )[],
                      PublicProps,
                      {
                          label: string;
                          messages: Message<any>[];
                          name: string;
                          noDefaultRules: boolean;
                          readonly: boolean;
                          rules: Rule<any>[];
                          state: UIState;
                          changed: boolean;
                          valid: boolean;
                          disabled: boolean;
                          hidden: boolean;
                          id: string;
                          noLabel: boolean;
                          noMessages: boolean;
                          required: boolean;
                          size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                          modelValue: any;
                          beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                          checked: boolean;
                          radioLabel: string;
                      },
                      true,
                      {},
                      {},
                      {
                          VsInputWrapper: DefineComponent<
                              ExtractPropTypes<{
                                  groupLabel: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  messages: {
                                      type: PropType<StateMessage<UIState>[]>;
                                      default: () => never[];
                                  };
                                  shake: {
                                      type: BooleanConstructor;
                                      default: boolean;
                                  };
                                  styleSet: {
                                      type: PropType<string | VsInputWrapperStyleSet>;
                                  };
                                  disabled: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  hidden: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  id: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  label: {
                                      type: typeof String;
                                      default: string;
                                  };
                                  noLabel: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  noMessages: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  required: {
                                      type: typeof Boolean;
                                      default: boolean;
                                  };
                                  width: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                                  grid: {
                                      type: PropType<string | number | Breakpoints>;
                                  };
                              }>,
                              {
                                  needToShake: Ref<boolean, boolean>;
                                  componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                  componentInlineStyle: ComputedRef<CSSProperties>;
                              },
                              {},
                              {},
                              {},
                              ComponentOptionsMixin,
                              ComponentOptionsMixin,
                              {},
                              string,
                              PublicProps,
                              Readonly<
                                  ExtractPropTypes<{
                                      groupLabel: {
                                          type: BooleanConstructor;
                                          default: boolean;
                                      };
                                      messages: {
                                          type: PropType<StateMessage<UIState>[]>;
                                          default: () => never[];
                                      };
                                      shake: {
                                          type: BooleanConstructor;
                                          default: boolean;
                                      };
                                      styleSet: {
                                          type: PropType<string | VsInputWrapperStyleSet>;
                                      };
                                      disabled: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      hidden: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      id: {
                                          type: typeof String;
                                          default: string;
                                      };
                                      label: {
                                          type: typeof String;
                                          default: string;
                                      };
                                      noLabel: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      noMessages: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      required: {
                                          type: typeof Boolean;
                                          default: boolean;
                                      };
                                      width: {
                                          type: PropType<string | number | Breakpoints>;
                                      };
                                      grid: {
                                          type: PropType<string | number | Breakpoints>;
                                      };
                                  }>
                              > &
                                  Readonly<{}>,
                              {
                                  label: string;
                                  messages: StateMessage<UIState>[];
                                  disabled: boolean;
                                  hidden: boolean;
                                  id: string;
                                  noLabel: boolean;
                                  noMessages: boolean;
                                  required: boolean;
                                  groupLabel: boolean;
                                  shake: boolean;
                              },
                              {},
                              {
                                  VsResponsive: DefineComponent<
                                      ExtractPropTypes<{
                                          tag: {
                                              type: StringConstructor;
                                              default: string;
                                          };
                                          width: {
                                              type: PropType<string | number | Breakpoints>;
                                          };
                                          grid: {
                                              type: PropType<string | number | Breakpoints>;
                                          };
                                      }>,
                                      {
                                          responsiveClasses: ComputedRef<string[]>;
                                          responsiveStyles: ComputedRef<Record<string, string>>;
                                      },
                                      {},
                                      {},
                                      {},
                                      ComponentOptionsMixin,
                                      ComponentOptionsMixin,
                                      {},
                                      string,
                                      PublicProps,
                                      Readonly<
                                          ExtractPropTypes<{
                                              tag: {
                                                  type: StringConstructor;
                                                  default: string;
                                              };
                                              width: {
                                                  type: PropType<string | number | Breakpoints>;
                                              };
                                              grid: {
                                                  type: PropType<string | number | Breakpoints>;
                                              };
                                          }>
                                      > &
                                          Readonly<{}>,
                                      {
                                          tag: string;
                                      },
                                      {},
                                      {},
                                      {},
                                      string,
                                      ComponentProvideOptions,
                                      true,
                                      {},
                                      any
                                  >;
                                  VsMessage: DefineComponent<
                                      ExtractPropTypes<{
                                          state: {
                                              type: PropType<UIState>;
                                              default: string;
                                          };
                                          text: {
                                              type: StringConstructor;
                                              default: string;
                                          };
                                          styleSet: {
                                              type: PropType<string | VsMessageStyleSet>;
                                          };
                                      }>,
                                      {
                                          colorClass: ComputedRef<
                                              | 'vs-cs-blue'
                                              | 'vs-cs-green'
                                              | 'vs-cs-amber'
                                              | 'vs-cs-red'
                                              | 'vs-cs-default'
                                          >;
                                          icon: ComputedRef<Component>;
                                          styleSetVariables: ComputedRef<Record<string, string>>;
                                          componentInlineStyle: ComputedRef<CSSProperties>;
                                      },
                                      {},
                                      {},
                                      {},
                                      ComponentOptionsMixin,
                                      ComponentOptionsMixin,
                                      {},
                                      string,
                                      PublicProps,
                                      Readonly<
                                          ExtractPropTypes<{
                                              state: {
                                                  type: PropType<UIState>;
                                                  default: string;
                                              };
                                              text: {
                                                  type: StringConstructor;
                                                  default: string;
                                              };
                                              styleSet: {
                                                  type: PropType<string | VsMessageStyleSet>;
                                              };
                                          }>
                                      > &
                                          Readonly<{}>,
                                      {
                                          text: string;
                                          state: UIState;
                                      },
                                      {},
                                      {},
                                      {},
                                      string,
                                      ComponentProvideOptions,
                                      true,
                                      {},
                                      any
                                  >;
                              },
                              {},
                              string,
                              ComponentProvideOptions,
                              true,
                              {},
                              any
                          >;
                      } & GlobalComponents,
                      GlobalDirectives,
                      string,
                      {},
                      any,
                      ComponentProvideOptions,
                      {
                          P: {};
                          B: {};
                          D: {};
                          C: {};
                          M: {};
                          Defaults: {};
                      },
                      Readonly<
                          ExtractPropTypes<{
                              beforeChange: {
                                  type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                  default: null;
                              };
                              checked: {
                                  type: BooleanConstructor;
                                  default: boolean;
                              };
                              radioLabel: {
                                  type: StringConstructor;
                                  default: string;
                              };
                              radioValue: {
                                  type: null;
                                  required: true;
                              };
                              size: {
                                  type: PropType<Size>;
                                  default: string;
                              };
                              modelValue: {
                                  type: null;
                                  default: null;
                              };
                              width: {
                                  type: PropType<string | number | Breakpoints>;
                              };
                              grid: {
                                  type: PropType<string | number | Breakpoints>;
                              };
                              label: {
                                  type: typeof String;
                                  default: string;
                              };
                              messages: {
                                  type: PropType<Message<any>[]>;
                                  default: () => Message<any>[];
                              };
                              name: {
                                  type: typeof String;
                                  default: string;
                              };
                              noDefaultRules: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              readonly: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              rules: {
                                  type: PropType<Rule<any>[]>;
                                  default: () => Rule<any>[];
                              };
                              state: {
                                  type: PropType<UIState>;
                                  default: UIState;
                              };
                              changed: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              valid: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              disabled: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              hidden: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              id: {
                                  type: typeof String;
                                  default: string;
                              };
                              noLabel: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              noMessages: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              required: {
                                  type: typeof Boolean;
                                  default: boolean;
                              };
                              styleSet: {
                                  type: PropType<string | VsRadioStyleSet>;
                              };
                              colorScheme: {
                                  type: PropType<ColorScheme>;
                              };
                          }>
                      > &
                          Readonly<{
                              onFocus?: ((...args: any[]) => any) | undefined;
                              onBlur?: ((...args: any[]) => any) | undefined;
                              onChange?: ((...args: any[]) => any) | undefined;
                              onToggle?: ((...args: any[]) => any) | undefined;
                              'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                              onClear?: ((...args: any[]) => any) | undefined;
                              'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                              'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                          }>,
                      {
                          computedId: ComputedRef<string>;
                          radioRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                          isChecked: ComputedRef<boolean>;
                          colorSchemeClass: ComputedRef<string>;
                          computedState: ComputedRef<UIState>;
                          componentStyleSet: ComputedRef<Partial<VsRadioStyleSet>>;
                          styleSetVariables: ComputedRef<Record<string, string>>;
                          classObj: ComputedRef<{
                              'vs-disabled': boolean;
                              'vs-focus-visible': boolean;
                              'vs-readonly': boolean;
                          }>;
                          sizeClass: ComputedRef<string>;
                          stateBoxClasses: ComputedRef<{}>;
                          computedDisabled: ComputedRef<boolean>;
                          computedReadonly: ComputedRef<boolean>;
                          inputValue: Ref<any, any>;
                          computedMessages: ComputedRef<StateMessage<UIState>[]>;
                          shake: Ref<boolean, boolean>;
                          validate: () => boolean;
                          clear: () => void;
                          reset: () => void;
                          onToggle: (event: Event) => Promise<void>;
                          onFocus: (e: FocusEvent) => void;
                          onBlur: (e: FocusEvent) => void;
                          focus: () => void;
                          blur: () => void;
                          convertToString: (value: any) => string;
                      },
                      {},
                      {},
                      {},
                      {
                          label: string;
                          messages: Message<any>[];
                          name: string;
                          noDefaultRules: boolean;
                          readonly: boolean;
                          rules: Rule<any>[];
                          state: UIState;
                          changed: boolean;
                          valid: boolean;
                          disabled: boolean;
                          hidden: boolean;
                          id: string;
                          noLabel: boolean;
                          noMessages: boolean;
                          required: boolean;
                          size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                          modelValue: any;
                          beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                          checked: boolean;
                          radioLabel: string;
                      }
                  >[]
                | null
            >
        >;
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsRadioSetStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            'vs-vertical': boolean;
        }>;
        sizeClass: ComputedRef<string>;
        computedId: ComputedRef<string>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        computedState: ComputedRef<UIState>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        shake: Ref<boolean, boolean>;
        inputValue: Ref<any, any>;
        getOptionLabel: (option: any) => string;
        getOptionValue: (option: any) => any;
        resolvedName: ComputedRef<string>;
        onRadioUpdate: (value: any) => void;
        onFocus: (option: any, event: FocusEvent) => void;
        onBlur: (option: any, event: FocusEvent) => void;
        validate: () => boolean;
        clear: () => void;
        reset: () => void;
        focus: () => void;
        blur: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
    'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                default: null;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: null;
                default: null;
            };
            options: {
                type: PropType<any[]>;
                default: () => never[];
            };
            optionLabel: {
                type: StringConstructor;
                default: string;
            };
            optionValue: {
                type: StringConstructor;
                default: string;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsRadioSetStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        messages: Message<any>[];
        name: string;
        noDefaultRules: boolean;
        readonly: boolean;
        rules: Rule<any>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        vertical: boolean;
        modelValue: any;
        beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
        options: any[];
        optionLabel: string;
        optionValue: string;
    },
    {},
    {
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsRadio: DefineComponent<
            ExtractPropTypes<{
                beforeChange: {
                    type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                    default: null;
                };
                checked: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                radioLabel: {
                    type: StringConstructor;
                    default: string;
                };
                radioValue: {
                    type: null;
                    required: true;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                modelValue: {
                    type: null;
                    default: null;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<any>[]>;
                    default: () => Message<any>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<any>[]>;
                    default: () => Rule<any>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsRadioStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                computedId: ComputedRef<string>;
                radioRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                isChecked: ComputedRef<boolean>;
                colorSchemeClass: ComputedRef<string>;
                computedState: ComputedRef<UIState>;
                componentStyleSet: ComputedRef<Partial<VsRadioStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                classObj: ComputedRef<{
                    'vs-disabled': boolean;
                    'vs-focus-visible': boolean;
                    'vs-readonly': boolean;
                }>;
                sizeClass: ComputedRef<string>;
                stateBoxClasses: ComputedRef<{}>;
                computedDisabled: ComputedRef<boolean>;
                computedReadonly: ComputedRef<boolean>;
                inputValue: Ref<any, any>;
                computedMessages: ComputedRef<StateMessage<UIState>[]>;
                shake: Ref<boolean, boolean>;
                validate: () => boolean;
                clear: () => void;
                reset: () => void;
                onToggle: (event: Event) => Promise<void>;
                onFocus: (e: FocusEvent) => void;
                onBlur: (e: FocusEvent) => void;
                focus: () => void;
                blur: () => void;
                convertToString: (value: any) => string;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            (
                | 'blur'
                | 'change'
                | 'focus'
                | 'toggle'
                | 'clear'
                | 'update:modelValue'
                | 'update:changed'
                | 'update:valid'
            )[],
            'blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    beforeChange: {
                        type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                        default: null;
                    };
                    checked: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    radioLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    radioValue: {
                        type: null;
                        required: true;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    modelValue: {
                        type: null;
                        default: null;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<any>[]>;
                        default: () => Message<any>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<any>[]>;
                        default: () => Rule<any>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsRadioStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    onToggle?: ((...args: any[]) => any) | undefined;
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    onClear?: ((...args: any[]) => any) | undefined;
                    'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                    'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                label: string;
                messages: Message<any>[];
                name: string;
                noDefaultRules: boolean;
                readonly: boolean;
                rules: Rule<any>[];
                state: UIState;
                changed: boolean;
                valid: boolean;
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                modelValue: any;
                beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                checked: boolean;
                radioLabel: string;
            },
            {},
            {
                VsInputWrapper: DefineComponent<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        needToShake: Ref<boolean, boolean>;
                        componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        label: string;
                        messages: StateMessage<UIState>[];
                        disabled: boolean;
                        hidden: boolean;
                        id: string;
                        noLabel: boolean;
                        noMessages: boolean;
                        required: boolean;
                        groupLabel: boolean;
                        shake: boolean;
                    },
                    {},
                    {
                        VsResponsive: DefineComponent<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>,
                            {
                                responsiveClasses: ComputedRef<string[]>;
                                responsiveStyles: ComputedRef<Record<string, string>>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                tag: string;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsMessage: DefineComponent<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>,
                            {
                                colorClass: ComputedRef<
                                    'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                >;
                                icon: ComputedRef<Component>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                text: string;
                                state: UIState;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsRadioSetRef extends ComponentPublicInstance<typeof VsRadioSet>, FocusableRef, FormChildRef {}

export declare interface VsRadioSetStyleSet extends CSSProperties {
    $radio?: VsRadioStyleSet;
    $wrapper?: VsInputWrapperStyleSet;
}

export declare interface VsRadioStyleSet {
    $radioBorderRadius?: string;
    $radioColor?: string;
    $radioSize?: string;
    $wrapper?: VsInputWrapperStyleSet;
}

export declare const VsRender: DefineComponent<
    ExtractPropTypes<{
        content: {
            type: PropType<string | Component>;
            required: true;
        };
        componentProps: {
            type: PropType<Record<string, any>>;
            default: () => {};
        };
    }>,
    () => VNode<
        RendererNode,
        RendererElement,
        {
            [key: string]: any;
        }
    >,
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            content: {
                type: PropType<string | Component>;
                required: true;
            };
            componentProps: {
                type: PropType<Record<string, any>>;
                default: () => {};
            };
        }>
    > &
        Readonly<{}>,
    {
        componentProps: Record<string, any>;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsRenderRef extends ComponentPublicInstance<typeof VsRender> {}

export declare const VsResponsive: DefineComponent<
    ExtractPropTypes<{
        tag: {
            type: StringConstructor;
            default: string;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
    }>,
    {
        responsiveClasses: ComputedRef<string[]>;
        responsiveStyles: ComputedRef<Record<string, string>>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            tag: {
                type: StringConstructor;
                default: string;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>
    > &
        Readonly<{}>,
    {
        tag: string;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsResponsiveRef extends ComponentPublicInstance<typeof VsResponsive> {}

export declare const VsSearchInput: DefineComponent<
    ExtractPropTypes<{
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        placeholder: {
            type: StringConstructor;
            default: string;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        useCaseSensitive: {
            type: BooleanConstructor;
            default: boolean;
        };
        useRegex: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: StringConstructor;
            default: string;
        };
        caseSensitive: {
            type: BooleanConstructor;
            default: boolean;
        };
        regex: {
            type: BooleanConstructor;
            default: boolean;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        styleSet: {
            type: PropType<string | VsSearchInputStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        inputRef: Readonly<ShallowRef<VsInputRef | null>>;
        searchText: Ref<string, string>;
        isCaseSensitiveOn: Ref<boolean, boolean>;
        isRegexOn: Ref<boolean, boolean>;
        computedColorScheme: ComputedRef<
            | 'brown'
            | 'red'
            | 'orange'
            | 'amber'
            | 'yellow'
            | 'lime'
            | 'green'
            | 'emerald'
            | 'teal'
            | 'cyan'
            | 'sky'
            | 'blue'
            | 'indigo'
            | 'violet'
            | 'purple'
            | 'fuchsia'
            | 'pink'
            | 'rose'
            | 'gray'
            | 'none'
            | undefined
        >;
        componentStyleSet: ComputedRef<Partial<VsSearchInputStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        onInputChange: (value: string | number | null) => void;
        match: (text: string) => boolean;
        focus: () => void;
        blur: () => void;
        select: () => void;
        clear: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex')[],
    'search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            placeholder: {
                type: StringConstructor;
                default: string;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            useCaseSensitive: {
                type: BooleanConstructor;
                default: boolean;
            };
            useRegex: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: StringConstructor;
                default: string;
            };
            caseSensitive: {
                type: BooleanConstructor;
                default: boolean;
            };
            regex: {
                type: BooleanConstructor;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            styleSet: {
                type: PropType<string | VsSearchInputStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onSearch?: ((...args: any[]) => any) | undefined;
            'onUpdate:caseSensitive'?: ((...args: any[]) => any) | undefined;
            'onUpdate:regex'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        placeholder: string;
        readonly: boolean;
        disabled: boolean;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        modelValue: string;
        useCaseSensitive: boolean;
        useRegex: boolean;
        caseSensitive: boolean;
        regex: boolean;
    },
    {},
    {
        VsInput: DefineComponent<
            ExtractPropTypes<{
                autocomplete: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                noClear: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<VsInputType>;
                    default: string;
                };
                modelValue: {
                    type: PropType<VsInputValueType>;
                    default: null;
                };
                modelModifiers: {
                    type: PropType<StringModifiers>;
                    default: () => {};
                };
                min: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                max: {
                    type: PropType<number | string>;
                    default: string | number;
                    validator: (value: number | string) => boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<VsInputValueType>[]>;
                    default: () => Message<VsInputValueType>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                placeholder: {
                    type: typeof String;
                    default: string;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<VsInputValueType>[]>;
                    default: () => Rule<VsInputValueType>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
            }>,
            {
                inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                classObj: ComputedRef<{
                    [x: string]: boolean;
                    'vs-focus-visible': boolean;
                    'vs-focus-within': boolean;
                    'vs-disabled': boolean;
                    'vs-readonly': boolean;
                }>;
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                inputValue: Ref<VsInputValueType, VsInputValueType>;
                computedMessages: ComputedRef<StateMessage<UIState>[]>;
                computedDisabled: ComputedRef<boolean>;
                computedReadonly: ComputedRef<boolean>;
                renderClearButton: ComputedRef<boolean>;
                shake: Ref<boolean, boolean>;
                stateBoxClasses: ComputedRef<{}>;
                computedId: ComputedRef<string>;
                onInput: (event: Event) => void;
                focus: () => void;
                blur: () => void;
                select: () => void;
                clear: () => void;
                reset: () => void;
                onFocus: (e: FocusEvent) => void;
                onBlur: (e: FocusEvent) => void;
                validate: () => boolean;
                clearWithFocus: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
            'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    autocomplete: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    noClear: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<VsInputType>;
                        default: string;
                    };
                    modelValue: {
                        type: PropType<VsInputValueType>;
                        default: null;
                    };
                    modelModifiers: {
                        type: PropType<StringModifiers>;
                        default: () => {};
                    };
                    min: {
                        type: PropType<number | string>;
                        default: string | number;
                        validator: (value: number | string) => boolean;
                    };
                    max: {
                        type: PropType<number | string>;
                        default: string | number;
                        validator: (value: number | string) => boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<VsInputValueType>[]>;
                        default: () => Message<VsInputValueType>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    placeholder: {
                        type: typeof String;
                        default: string;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<VsInputValueType>[]>;
                        default: () => Rule<VsInputValueType>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                }>
            > &
                Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    onClear?: ((...args: any[]) => any) | undefined;
                    'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                    'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                label: string;
                messages: Message<VsInputValueType>[];
                name: string;
                noDefaultRules: boolean;
                placeholder: string;
                readonly: boolean;
                rules: Rule<VsInputValueType>[];
                state: UIState;
                changed: boolean;
                valid: boolean;
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                min: string | number;
                max: string | number;
                type: VsInputType;
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                modelValue: VsInputValueType;
                autocomplete: boolean;
                noClear: boolean;
                modelModifiers: StringModifiers;
            },
            {},
            {
                VsInputWrapper: DefineComponent<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        needToShake: Ref<boolean, boolean>;
                        componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        label: string;
                        messages: StateMessage<UIState>[];
                        disabled: boolean;
                        hidden: boolean;
                        id: string;
                        noLabel: boolean;
                        noMessages: boolean;
                        required: boolean;
                        groupLabel: boolean;
                        shake: boolean;
                    },
                    {},
                    {
                        VsResponsive: DefineComponent<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>,
                            {
                                responsiveClasses: ComputedRef<string[]>;
                                responsiveStyles: ComputedRef<Record<string, string>>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                tag: string;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsMessage: DefineComponent<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>,
                            {
                                colorClass: ComputedRef<
                                    'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                >;
                                icon: ComputedRef<Component>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                text: string;
                                state: UIState;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                XIcon: LucideIcon;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsToggle: DefineComponent<
            ExtractPropTypes<{
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                circle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<'button' | 'submit' | 'reset'>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsToggleStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                toggle: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('toggle' | 'update:modelValue')[],
            'toggle' | 'update:modelValue',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsToggleStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    onToggle?: ((...args: any[]) => any) | undefined;
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                circle: boolean;
                disabled: boolean;
                type: 'button' | 'reset' | 'submit';
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                outline: boolean;
                primary: boolean;
                modelValue: boolean;
                ghost: boolean;
                loading: boolean;
                responsive: boolean;
            },
            {},
            {
                VsButton: DefineComponent<
                    ExtractPropTypes<{
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsButtonStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                        classObj: ComputedRef<{
                            [x: string]: boolean;
                            'vs-focus-visible': boolean;
                            'vs-circle': boolean;
                            'vs-disabled': boolean;
                            'vs-ghost': boolean;
                            'vs-loading-state': boolean;
                            'vs-outline': boolean;
                            'vs-primary': boolean;
                            'vs-responsive': boolean;
                        }>;
                        buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                        componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsButtonStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        circle: boolean;
                        disabled: boolean;
                        type: 'button' | 'reset' | 'submit';
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        outline: boolean;
                        primary: boolean;
                        ghost: boolean;
                        loading: boolean;
                        responsive: boolean;
                    },
                    {},
                    {
                        VsLoading: DefineComponent<
                            ExtractPropTypes<{
                                width: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                height: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                styleSet: {
                                    type: PropType<string | VsLoadingStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                colorSchemeClass: ComputedRef<string>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    width: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    height: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    styleSet: {
                                        type: PropType<string | VsLoadingStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {},
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsSearchInputRef extends ComponentPublicInstance<typeof VsSearchInput>, FocusableRef {
    match: (text: string) => boolean;
    select: () => void;
}

export declare interface VsSearchInputStyleSet extends VsInputStyleSet {
    $toggle?: VsToggleStyleSet;
}

export declare const VsSelect: DefineComponent<
    ExtractPropTypes<{
        closableChips: {
            type: BooleanConstructor;
            default: boolean;
        };
        collapseChips: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        noClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        optionsDisabled: {
            type: PropType<boolean | ((option: any, index: number, options: any[]) => boolean)>;
            default: boolean;
        };
        selectAll: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        modelValue: {
            type: null;
            default: null;
        };
        search: {
            type: PropType<SearchProps>;
            default: boolean;
            validator: (value: SearchProps) => boolean;
        };
        min: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        max: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        groupBy: {
            type: PropType<(option: any, index: number) => string | null> | null;
            default: null;
        };
        groupOrder: {
            type: PropType<string[]>;
            default: () => never[];
        };
        options: {
            type: PropType<any[]>;
            default: () => never[];
        };
        optionLabel: {
            type: StringConstructor;
            default: string;
        };
        optionValue: {
            type: StringConstructor;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsSelectStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<any>[]>;
            default: () => Message<any>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        placeholder: {
            type: typeof String;
            default: string;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<any>[]>;
            default: () => Rule<any>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
    }>,
    {
        triggerRef: Readonly<ShallowRef<VsSelectTriggerRef | null>>;
        searchInputRef: Readonly<ShallowRef<VsSearchInputRef | null>>;
        optionsListRef: Readonly<ShallowRef<VsGroupedListRef | null>>;
        triggerId: ComputedRef<string>;
        optionsId: ComputedRef<string>;
        isOpen: Ref<boolean, boolean>;
        inputValue: Ref<any, any>;
        colorSchemeClass: ComputedRef<string>;
        sizeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentStyleSet: ComputedRef<Partial<VsSelectStyleSet>>;
        classObj: ComputedRef<{
            [x: string]: boolean;
            'vs-disabled': boolean;
            'vs-readonly': boolean;
        }>;
        computedId: ComputedRef<string>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        computedState: ComputedRef<UIState>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        filteredOptions: ComputedRef<OptionItem[]>;
        shake: Ref<boolean, boolean>;
        openOptions: () => void;
        closeOptions: () => void;
        isSelected: (optionId: string) => boolean;
        toggleSelectAll: () => void;
        isUsingSearch: ComputedRef<boolean>;
        searchProps: ComputedRef<{
            useRegex: boolean;
            useCaseSensitive: boolean;
            placeholder: string;
        }>;
        toggleOpen: () => void;
        selectOptionItem: (optionItem: OptionItem) => void;
        isSelectedAll: ComputedRef<boolean>;
        computedColorScheme: ComputedRef<
            | 'brown'
            | 'red'
            | 'orange'
            | 'amber'
            | 'yellow'
            | 'lime'
            | 'green'
            | 'emerald'
            | 'teal'
            | 'cyan'
            | 'sky'
            | 'blue'
            | 'indigo'
            | 'violet'
            | 'purple'
            | 'fuchsia'
            | 'pink'
            | 'rose'
            | 'gray'
            | 'none'
            | undefined
        >;
        onFocus: (e: FocusEvent) => void;
        onBlur: (e: FocusEvent) => void;
        focus: () => void;
        blur: () => void;
        validate: () => boolean;
        clear: () => void;
        reset: () => void;
        isEmpty: ComputedRef<boolean>;
        selectedOptions: ComputedRef<OptionItem[]>;
        deselectOption: (optionId: string) => void;
        getOptionStyleSet: (optionId: string) => CSSProperties;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    (
        | 'blur'
        | 'change'
        | 'close'
        | 'focus'
        | 'open'
        | 'clear'
        | 'update:modelValue'
        | 'update:changed'
        | 'update:valid'
        | 'click-option'
    )[],
    | 'blur'
    | 'change'
    | 'close'
    | 'focus'
    | 'open'
    | 'clear'
    | 'update:modelValue'
    | 'update:changed'
    | 'update:valid'
    | 'click-option',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            closableChips: {
                type: BooleanConstructor;
                default: boolean;
            };
            collapseChips: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            optionsDisabled: {
                type: PropType<boolean | ((option: any, index: number, options: any[]) => boolean)>;
                default: boolean;
            };
            selectAll: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: null;
                default: null;
            };
            search: {
                type: PropType<SearchProps>;
                default: boolean;
                validator: (value: SearchProps) => boolean;
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            groupBy: {
                type: PropType<(option: any, index: number) => string | null> | null;
                default: null;
            };
            groupOrder: {
                type: PropType<string[]>;
                default: () => never[];
            };
            options: {
                type: PropType<any[]>;
                default: () => never[];
            };
            optionLabel: {
                type: StringConstructor;
                default: string;
            };
            optionValue: {
                type: StringConstructor;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsSelectStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
            onClose?: ((...args: any[]) => any) | undefined;
            onOpen?: ((...args: any[]) => any) | undefined;
            'onClick-option'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        search: SearchProps;
        messages: Message<any>[];
        name: string;
        noDefaultRules: boolean;
        placeholder: string;
        readonly: boolean;
        rules: Rule<any>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        min: string | number;
        max: string | number;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        multiple: boolean;
        modelValue: any;
        options: any[];
        optionLabel: string;
        optionValue: string;
        noClear: boolean;
        groupBy: (option: any, index: number) => string | null;
        groupOrder: string[];
        collapseChips: boolean;
        closableChips: boolean;
        optionsDisabled: boolean | ((option: any, index: number, options: any[]) => boolean);
        selectAll: boolean;
    },
    {},
    {
        VsFloating: DefineComponent<
            ExtractPropTypes<{
                followWidth: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                overlayId: {
                    type: StringConstructor;
                    default: string;
                };
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                target: {
                    type: StringConstructor;
                    required: boolean;
                    default: string;
                };
                align: {
                    type: PropType<Alignment>;
                    default: 'start' | 'center' | 'end';
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                enterDelay: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                leaveDelay: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                margin: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                noAnimation: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                placement: {
                    type: PropType<Placement>;
                    default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                };
            }>,
            {
                floatingRef: Readonly<ShallowRef<HTMLElement | null>>;
                computedPlacement: Ref<
                    'top' | 'right' | 'bottom' | 'left' | 'middle' | null,
                    'top' | 'right' | 'bottom' | 'left' | 'middle' | null
                >;
                isVisible: Ref<boolean, boolean>;
                isFloated: Ref<boolean, boolean>;
                animationClass: ComputedRef<string | null>;
                floatingStyle: ComputedRef<
                    | {
                          animationDelay?: undefined;
                      }
                    | {
                          animationDelay: string;
                      }
                >;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            'update:modelValue'[],
            'update:modelValue',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    followWidth: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    overlayId: {
                        type: StringConstructor;
                        default: string;
                    };
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    target: {
                        type: StringConstructor;
                        required: boolean;
                        default: string;
                    };
                    align: {
                        type: PropType<Alignment>;
                        default: 'start' | 'center' | 'end';
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    enterDelay: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    leaveDelay: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    margin: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    noAnimation: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placement: {
                        type: PropType<Placement>;
                        default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                    };
                }>
            > &
                Readonly<{
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                disabled: boolean;
                margin: string | number;
                modelValue: boolean;
                target: string;
                placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                overlayId: string;
                followWidth: boolean;
                align: 'start' | 'center' | 'end';
                enterDelay: string | number;
                leaveDelay: string | number;
                noAnimation: boolean;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsSearchInput: DefineComponent<
            ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                placeholder: {
                    type: StringConstructor;
                    default: string;
                };
                readonly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                useCaseSensitive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                useRegex: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modelValue: {
                    type: StringConstructor;
                    default: string;
                };
                caseSensitive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                regex: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                styleSet: {
                    type: PropType<string | VsSearchInputStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                inputRef: Readonly<ShallowRef<VsInputRef | null>>;
                searchText: Ref<string, string>;
                isCaseSensitiveOn: Ref<boolean, boolean>;
                isRegexOn: Ref<boolean, boolean>;
                computedColorScheme: ComputedRef<
                    | 'brown'
                    | 'red'
                    | 'orange'
                    | 'amber'
                    | 'yellow'
                    | 'lime'
                    | 'green'
                    | 'emerald'
                    | 'teal'
                    | 'cyan'
                    | 'sky'
                    | 'blue'
                    | 'indigo'
                    | 'violet'
                    | 'purple'
                    | 'fuchsia'
                    | 'pink'
                    | 'rose'
                    | 'gray'
                    | 'none'
                    | undefined
                >;
                componentStyleSet: ComputedRef<Partial<VsSearchInputStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                onInputChange: (value: string | number | null) => void;
                match: (text: string) => boolean;
                focus: () => void;
                blur: () => void;
                select: () => void;
                clear: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex')[],
            'search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: string;
                    };
                    readonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    useCaseSensitive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    useRegex: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: string;
                    };
                    caseSensitive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    regex: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    styleSet: {
                        type: PropType<string | VsSearchInputStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    onSearch?: ((...args: any[]) => any) | undefined;
                    'onUpdate:caseSensitive'?: ((...args: any[]) => any) | undefined;
                    'onUpdate:regex'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                placeholder: string;
                readonly: boolean;
                disabled: boolean;
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                modelValue: string;
                useCaseSensitive: boolean;
                useRegex: boolean;
                caseSensitive: boolean;
                regex: boolean;
            },
            {},
            {
                VsInput: DefineComponent<
                    ExtractPropTypes<{
                        autocomplete: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        noClear: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<VsInputType>;
                            default: string;
                        };
                        modelValue: {
                            type: PropType<VsInputValueType>;
                            default: null;
                        };
                        modelModifiers: {
                            type: PropType<StringModifiers>;
                            default: () => {};
                        };
                        min: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        max: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        messages: {
                            type: PropType<Message<VsInputValueType>[]>;
                            default: () => Message<VsInputValueType>[];
                        };
                        name: {
                            type: typeof String;
                            default: string;
                        };
                        noDefaultRules: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        placeholder: {
                            type: typeof String;
                            default: string;
                        };
                        readonly: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        rules: {
                            type: PropType<Rule<VsInputValueType>[]>;
                            default: () => Rule<VsInputValueType>[];
                        };
                        state: {
                            type: PropType<UIState>;
                            default: UIState;
                        };
                        changed: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        valid: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                    }>,
                    {
                        inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                        classObj: ComputedRef<{
                            [x: string]: boolean;
                            'vs-focus-visible': boolean;
                            'vs-focus-within': boolean;
                            'vs-disabled': boolean;
                            'vs-readonly': boolean;
                        }>;
                        colorSchemeClass: ComputedRef<string>;
                        componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                        inputValue: Ref<VsInputValueType, VsInputValueType>;
                        computedMessages: ComputedRef<StateMessage<UIState>[]>;
                        computedDisabled: ComputedRef<boolean>;
                        computedReadonly: ComputedRef<boolean>;
                        renderClearButton: ComputedRef<boolean>;
                        shake: Ref<boolean, boolean>;
                        stateBoxClasses: ComputedRef<{}>;
                        computedId: ComputedRef<string>;
                        onInput: (event: Event) => void;
                        focus: () => void;
                        blur: () => void;
                        select: () => void;
                        clear: () => void;
                        reset: () => void;
                        onFocus: (e: FocusEvent) => void;
                        onBlur: (e: FocusEvent) => void;
                        validate: () => boolean;
                        clearWithFocus: () => void;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
                    'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            autocomplete: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            noClear: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<VsInputType>;
                                default: string;
                            };
                            modelValue: {
                                type: PropType<VsInputValueType>;
                                default: null;
                            };
                            modelModifiers: {
                                type: PropType<StringModifiers>;
                                default: () => {};
                            };
                            min: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            max: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            messages: {
                                type: PropType<Message<VsInputValueType>[]>;
                                default: () => Message<VsInputValueType>[];
                            };
                            name: {
                                type: typeof String;
                                default: string;
                            };
                            noDefaultRules: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            placeholder: {
                                type: typeof String;
                                default: string;
                            };
                            readonly: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            rules: {
                                type: PropType<Rule<VsInputValueType>[]>;
                                default: () => Rule<VsInputValueType>[];
                            };
                            state: {
                                type: PropType<UIState>;
                                default: UIState;
                            };
                            changed: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            valid: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                        }>
                    > &
                        Readonly<{
                            onFocus?: ((...args: any[]) => any) | undefined;
                            onBlur?: ((...args: any[]) => any) | undefined;
                            onChange?: ((...args: any[]) => any) | undefined;
                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                            onClear?: ((...args: any[]) => any) | undefined;
                            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        label: string;
                        messages: Message<VsInputValueType>[];
                        name: string;
                        noDefaultRules: boolean;
                        placeholder: string;
                        readonly: boolean;
                        rules: Rule<VsInputValueType>[];
                        state: UIState;
                        changed: boolean;
                        valid: boolean;
                        disabled: boolean;
                        hidden: boolean;
                        id: string;
                        noLabel: boolean;
                        noMessages: boolean;
                        required: boolean;
                        min: string | number;
                        max: string | number;
                        type: VsInputType;
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        modelValue: VsInputValueType;
                        autocomplete: boolean;
                        noClear: boolean;
                        modelModifiers: StringModifiers;
                    },
                    {},
                    {
                        VsInputWrapper: DefineComponent<
                            ExtractPropTypes<{
                                groupLabel: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                messages: {
                                    type: PropType<StateMessage<UIState>[]>;
                                    default: () => never[];
                                };
                                shake: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputWrapperStyleSet>;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>,
                            {
                                needToShake: Ref<boolean, boolean>;
                                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    groupLabel: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    messages: {
                                        type: PropType<StateMessage<UIState>[]>;
                                        default: () => never[];
                                    };
                                    shake: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsInputWrapperStyleSet>;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                label: string;
                                messages: StateMessage<UIState>[];
                                disabled: boolean;
                                hidden: boolean;
                                id: string;
                                noLabel: boolean;
                                noMessages: boolean;
                                required: boolean;
                                groupLabel: boolean;
                                shake: boolean;
                            },
                            {},
                            {
                                VsResponsive: DefineComponent<
                                    ExtractPropTypes<{
                                        tag: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>,
                                    {
                                        responsiveClasses: ComputedRef<string[]>;
                                        responsiveStyles: ComputedRef<Record<string, string>>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            tag: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        tag: string;
                                    },
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                                VsMessage: DefineComponent<
                                    ExtractPropTypes<{
                                        state: {
                                            type: PropType<UIState>;
                                            default: string;
                                        };
                                        text: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsMessageStyleSet>;
                                        };
                                    }>,
                                    {
                                        colorClass: ComputedRef<
                                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                        >;
                                        icon: ComputedRef<Component>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            state: {
                                                type: PropType<UIState>;
                                                default: string;
                                            };
                                            text: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsMessageStyleSet>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        text: string;
                                        state: UIState;
                                    },
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        XIcon: LucideIcon;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsToggle: DefineComponent<
                    ExtractPropTypes<{
                        modelValue: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsToggleStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        toggle: () => void;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    ('toggle' | 'update:modelValue')[],
                    'toggle' | 'update:modelValue',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            modelValue: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsToggleStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{
                            onToggle?: ((...args: any[]) => any) | undefined;
                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        circle: boolean;
                        disabled: boolean;
                        type: 'button' | 'reset' | 'submit';
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        outline: boolean;
                        primary: boolean;
                        modelValue: boolean;
                        ghost: boolean;
                        loading: boolean;
                        responsive: boolean;
                    },
                    {},
                    {
                        VsButton: DefineComponent<
                            ExtractPropTypes<{
                                circle: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                responsive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<'button' | 'submit' | 'reset'>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsButtonStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                colorSchemeClass: ComputedRef<string>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                                classObj: ComputedRef<{
                                    [x: string]: boolean;
                                    'vs-focus-visible': boolean;
                                    'vs-circle': boolean;
                                    'vs-disabled': boolean;
                                    'vs-ghost': boolean;
                                    'vs-loading-state': boolean;
                                    'vs-outline': boolean;
                                    'vs-primary': boolean;
                                    'vs-responsive': boolean;
                                }>;
                                buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    circle: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    ghost: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    loading: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    outline: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    primary: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    responsive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    type: {
                                        type: PropType<'button' | 'submit' | 'reset'>;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsButtonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                circle: boolean;
                                disabled: boolean;
                                type: 'button' | 'reset' | 'submit';
                                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                outline: boolean;
                                primary: boolean;
                                ghost: boolean;
                                loading: boolean;
                                responsive: boolean;
                            },
                            {},
                            {
                                VsLoading: DefineComponent<
                                    ExtractPropTypes<{
                                        width: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        height: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        styleSet: {
                                            type: PropType<string | VsLoadingStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>,
                                    {
                                        colorSchemeClass: ComputedRef<string>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            width: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            styleSet: {
                                                type: PropType<string | VsLoadingStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {},
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsCheckbox: DefineComponent<
            ExtractPropTypes<{
                beforeChange: {
                    type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                    default: null;
                };
                checked: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                checkLabel: {
                    type: StringConstructor;
                    default: string;
                };
                indeterminate: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                trueValue: {
                    type: null;
                    default: boolean;
                };
                falseValue: {
                    type: null;
                    default: boolean;
                };
                modelValue: {
                    type: null;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                messages: {
                    type: PropType<Message<any>[]>;
                    default: () => Message<any>[];
                };
                name: {
                    type: typeof String;
                    default: string;
                };
                noDefaultRules: {
                    type: typeof Boolean;
                    default: boolean;
                };
                readonly: {
                    type: typeof Boolean;
                    default: boolean;
                };
                rules: {
                    type: PropType<Rule<any>[]>;
                    default: () => Rule<any>[];
                };
                state: {
                    type: PropType<UIState>;
                    default: UIState;
                };
                changed: {
                    type: typeof Boolean;
                    default: boolean;
                };
                valid: {
                    type: typeof Boolean;
                    default: boolean;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsCheckboxStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    'vs-checked': boolean;
                    'vs-disabled': boolean;
                    'vs-focus-visible': boolean;
                    'vs-indeterminate': boolean;
                    'vs-readonly': boolean;
                }>;
                sizeClass: ComputedRef<string>;
                stateBoxClasses: ComputedRef<{}>;
                computedId: ComputedRef<string>;
                computedDisabled: ComputedRef<boolean>;
                computedReadonly: ComputedRef<boolean>;
                computedMessages: ComputedRef<StateMessage<UIState>[]>;
                computedState: ComputedRef<UIState>;
                convertToString: (value: any) => string;
                inputValue: Ref<any, any>;
                isChecked: ComputedRef<boolean>;
                shake: Ref<boolean, boolean>;
                toggle: (e: MouseEvent) => Promise<void>;
                onFocus: (e: FocusEvent) => void;
                onBlur: (e: FocusEvent) => void;
                validate: () => boolean;
                clear: () => void;
                reset: () => void;
                focus: () => void;
                blur: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            (
                | 'blur'
                | 'change'
                | 'focus'
                | 'toggle'
                | 'clear'
                | 'update:modelValue'
                | 'update:changed'
                | 'update:valid'
            )[],
            'blur' | 'change' | 'focus' | 'toggle' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    beforeChange: {
                        type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                        default: null;
                    };
                    checked: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    checkLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    indeterminate: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    multiple: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    trueValue: {
                        type: null;
                        default: boolean;
                    };
                    falseValue: {
                        type: null;
                        default: boolean;
                    };
                    modelValue: {
                        type: null;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    messages: {
                        type: PropType<Message<any>[]>;
                        default: () => Message<any>[];
                    };
                    name: {
                        type: typeof String;
                        default: string;
                    };
                    noDefaultRules: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    readonly: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    rules: {
                        type: PropType<Rule<any>[]>;
                        default: () => Rule<any>[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: UIState;
                    };
                    changed: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    valid: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsCheckboxStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onChange?: ((...args: any[]) => any) | undefined;
                    onToggle?: ((...args: any[]) => any) | undefined;
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    onClear?: ((...args: any[]) => any) | undefined;
                    'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                    'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                label: string;
                messages: Message<any>[];
                name: string;
                noDefaultRules: boolean;
                readonly: boolean;
                rules: Rule<any>[];
                state: UIState;
                changed: boolean;
                valid: boolean;
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                multiple: boolean;
                modelValue: any;
                beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                checked: boolean;
                checkLabel: string;
                indeterminate: boolean;
                trueValue: any;
                falseValue: any;
            },
            {},
            {
                VsInputWrapper: DefineComponent<
                    ExtractPropTypes<{
                        groupLabel: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        messages: {
                            type: PropType<StateMessage<UIState>[]>;
                            default: () => never[];
                        };
                        shake: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputWrapperStyleSet>;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        needToShake: Ref<boolean, boolean>;
                        componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            groupLabel: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            messages: {
                                type: PropType<StateMessage<UIState>[]>;
                                default: () => never[];
                            };
                            shake: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputWrapperStyleSet>;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        label: string;
                        messages: StateMessage<UIState>[];
                        disabled: boolean;
                        hidden: boolean;
                        id: string;
                        noLabel: boolean;
                        noMessages: boolean;
                        required: boolean;
                        groupLabel: boolean;
                        shake: boolean;
                    },
                    {},
                    {
                        VsResponsive: DefineComponent<
                            ExtractPropTypes<{
                                tag: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>,
                            {
                                responsiveClasses: ComputedRef<string[]>;
                                responsiveStyles: ComputedRef<Record<string, string>>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    tag: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                tag: string;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsMessage: DefineComponent<
                            ExtractPropTypes<{
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                                text: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsMessageStyleSet>;
                                };
                            }>,
                            {
                                colorClass: ComputedRef<
                                    'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                >;
                                icon: ComputedRef<Component>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                    text: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsMessageStyleSet>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                text: string;
                                state: UIState;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsGroupedList: DefineComponent<
            ExtractPropTypes<{
                items: {
                    type: PropType<OptionItem[]>;
                    default: () => never[];
                };
                groupBy: {
                    type: PropType<(option: any, index: number) => string | null> | null;
                    default: null;
                };
                groupOrder: {
                    type: PropType<string[]>;
                    default: () => never[];
                };
                styleSet: {
                    type: PropType<string | VsGroupedListStyleSet>;
                };
            }>,
            {
                visibleRenderRef: Readonly<ShallowRef<VsVisibleRenderRef | null>>;
                innerScrollRef: Readonly<ShallowRef<VsInnerScrollRef | null>>;
                componentStyleSet: ComputedRef<Partial<VsGroupedListStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                groupedItems: ComputedRef<VsGroupedListGroup[]>;
                emitClickItem: (
                    item: OptionItem,
                    groupedIndex: number,
                    group: VsGroupedListGroup,
                    groupIndex: number,
                ) => void;
                scrollToItem: (id: string) => void;
                hasScroll: () => boolean;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            'click-item'[],
            'click-item',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    items: {
                        type: PropType<OptionItem[]>;
                        default: () => never[];
                    };
                    groupBy: {
                        type: PropType<(option: any, index: number) => string | null> | null;
                        default: null;
                    };
                    groupOrder: {
                        type: PropType<string[]>;
                        default: () => never[];
                    };
                    styleSet: {
                        type: PropType<string | VsGroupedListStyleSet>;
                    };
                }>
            > &
                Readonly<{
                    'onClick-item'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                items: OptionItem[];
                groupBy: (option: any, index: number) => string | null;
                groupOrder: string[];
            },
            {},
            {
                VsInnerScroll: DefineComponent<
                    ExtractPropTypes<{
                        hideScroll: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInnerScrollStyleSet>;
                        };
                    }>,
                    {
                        componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                        hasScroll: () => boolean;
                        bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            hideScroll: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInnerScrollStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        hideScroll: boolean;
                    },
                    {},
                    {},
                    {
                        scrollShadow: Directive<HTMLElement, boolean | undefined>;
                    },
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsVisibleRender: DefineComponent<
                    ExtractPropTypes<{
                        selector: {
                            type: StringConstructor;
                            default: null;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        rootMargin: {
                            type: StringConstructor;
                            default: string;
                        };
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        threshold: {
                            type: NumberConstructor;
                            default: number;
                            validator: (value: number) => boolean;
                        };
                    }>,
                    {
                        containerStyle: ComputedRef<
                            | {
                                  height?: undefined;
                                  overflowY?: undefined;
                              }
                            | {
                                  height: string;
                                  overflowY: string;
                              }
                        >;
                        scrollToElement: (element: HTMLElement) => void;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            selector: {
                                type: StringConstructor;
                                default: null;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            rootMargin: {
                                type: StringConstructor;
                                default: string;
                            };
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            threshold: {
                                type: NumberConstructor;
                                default: number;
                                validator: (value: number) => boolean;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        disabled: boolean;
                        tag: string;
                        selector: string;
                        rootMargin: string;
                        threshold: number;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsSelectTrigger: DefineComponent<
            ExtractPropTypes<{
                styleSet: {
                    type: PropType<VsSelectStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
                collapseChips: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                closableChips: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                isEmpty: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                isOpen: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                noClear: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                placeholder: {
                    type: StringConstructor;
                    default: string;
                };
                readonly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                selectedOptions: {
                    type: PropType<OptionItem[]>;
                    default: () => never[];
                };
                state: {
                    type: PropType<UIState>;
                    default: string;
                };
            }>,
            {
                triggerRef: Readonly<ShallowRef<HTMLElement | null>>;
                stateBoxClasses: ComputedRef<{}>;
                renderClearButton: ComputedRef<boolean>;
                displayLabel: ComputedRef<string>;
                triggerClassObj: ComputedRef<{
                    'vs-focusable': boolean;
                    'vs-focus-within': boolean;
                }>;
                componentStyleSet: ComputedRef<Partial<VsSelectStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                focus: () => void;
                blur: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('click' | 'blur' | 'focus' | 'clear' | 'deselect')[],
            'click' | 'blur' | 'focus' | 'clear' | 'deselect',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    styleSet: {
                        type: PropType<VsSelectStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                    collapseChips: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    closableChips: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    isEmpty: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    isOpen: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    multiple: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    noClear: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: string;
                    };
                    readonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    selectedOptions: {
                        type: PropType<OptionItem[]>;
                        default: () => never[];
                    };
                    state: {
                        type: PropType<UIState>;
                        default: string;
                    };
                }>
            > &
                Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    onClick?: ((...args: any[]) => any) | undefined;
                    onClear?: ((...args: any[]) => any) | undefined;
                    onDeselect?: ((...args: any[]) => any) | undefined;
                }>,
            {
                placeholder: string;
                readonly: boolean;
                state: UIState;
                disabled: boolean;
                multiple: boolean;
                isOpen: boolean;
                noClear: boolean;
                collapseChips: boolean;
                closableChips: boolean;
                isEmpty: boolean;
                selectedOptions: OptionItem[];
            },
            {},
            {
                VsChip: DefineComponent<
                    ExtractPropTypes<{
                        closable: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsChipStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        componentStyleSet: ComputedRef<Partial<VsChipStyleSet>>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                        classObj: ComputedRef<{
                            [x: string]: boolean;
                            'vs-outline': boolean;
                            'vs-primary': boolean;
                        }>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    'close'[],
                    'close',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            closable: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsChipStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{
                            onClose?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        outline: boolean;
                        primary: boolean;
                        closable: boolean;
                    },
                    {},
                    {
                        XIcon: LucideIcon;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                ChevronDownIcon: LucideIcon;
                XIcon: LucideIcon;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsSelectRef extends ComponentPublicInstance<typeof VsSelect> {}

export declare interface VsSelectStyleSet extends CSSProperties {
    $wrapper?: VsInputWrapperStyleSet;
    $chip?: VsChipStyleSet;
    $selectAllCheckbox?: VsCheckboxStyleSet;
    $options?: VsGroupedListStyleSet;
    $option?: CSSProperties & {
        $focused?: CSSProperties;
        $selected?: CSSProperties;
    };
}

export declare const VsSelectTrigger: DefineComponent<
    ExtractPropTypes<{
        styleSet: {
            type: PropType<VsSelectStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        collapseChips: {
            type: BooleanConstructor;
            default: boolean;
        };
        closableChips: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        isEmpty: {
            type: BooleanConstructor;
            default: boolean;
        };
        isOpen: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        noClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        placeholder: {
            type: StringConstructor;
            default: string;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        selectedOptions: {
            type: PropType<OptionItem[]>;
            default: () => never[];
        };
        state: {
            type: PropType<UIState>;
            default: string;
        };
    }>,
    {
        triggerRef: Readonly<ShallowRef<HTMLElement | null>>;
        stateBoxClasses: ComputedRef<{}>;
        renderClearButton: ComputedRef<boolean>;
        displayLabel: ComputedRef<string>;
        triggerClassObj: ComputedRef<{
            'vs-focusable': boolean;
            'vs-focus-within': boolean;
        }>;
        componentStyleSet: ComputedRef<Partial<VsSelectStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        focus: () => void;
        blur: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('click' | 'blur' | 'focus' | 'clear' | 'deselect')[],
    'click' | 'blur' | 'focus' | 'clear' | 'deselect',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            styleSet: {
                type: PropType<VsSelectStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            collapseChips: {
                type: BooleanConstructor;
                default: boolean;
            };
            closableChips: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            isEmpty: {
                type: BooleanConstructor;
                default: boolean;
            };
            isOpen: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            noClear: {
                type: BooleanConstructor;
                default: boolean;
            };
            placeholder: {
                type: StringConstructor;
                default: string;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            selectedOptions: {
                type: PropType<OptionItem[]>;
                default: () => never[];
            };
            state: {
                type: PropType<UIState>;
                default: string;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onClick?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            onDeselect?: ((...args: any[]) => any) | undefined;
        }>,
    {
        placeholder: string;
        readonly: boolean;
        state: UIState;
        disabled: boolean;
        multiple: boolean;
        isOpen: boolean;
        noClear: boolean;
        collapseChips: boolean;
        closableChips: boolean;
        isEmpty: boolean;
        selectedOptions: OptionItem[];
    },
    {},
    {
        VsChip: DefineComponent<
            ExtractPropTypes<{
                closable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsChipStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsChipStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    [x: string]: boolean;
                    'vs-outline': boolean;
                    'vs-primary': boolean;
                }>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            'close'[],
            'close',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    closable: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsChipStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    onClose?: ((...args: any[]) => any) | undefined;
                }>,
            {
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                outline: boolean;
                primary: boolean;
                closable: boolean;
            },
            {},
            {
                XIcon: LucideIcon;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        ChevronDownIcon: LucideIcon;
        XIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsSelectTriggerRef extends ComponentPublicInstance<typeof VsSelectTrigger>, FocusableRef {}

export declare const VsSkeleton: DefineComponent<
    ExtractPropTypes<{
        styleSet: {
            type: PropType<string | VsSkeletonStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsSkeletonStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            styleSet: {
                type: PropType<string | VsSkeletonStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {},
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsSkeletonRef extends ComponentPublicInstance<typeof VsSkeleton> {}

export declare interface VsSkeletonStyleSet extends CSSProperties {
    $background?: CSSProperties;
    $content?: CSSProperties;
}

export declare const VsSteps: DefineComponent<
    ExtractPropTypes<{
        disabled: {
            type: PropType<boolean | ((step: string, index: number) => boolean)>;
            default: boolean;
        };
        height: {
            type: (StringConstructor | NumberConstructor)[];
        };
        noLabel: {
            type: BooleanConstructor;
            default: boolean;
        };
        steps: {
            type: PropType<string[]>;
            default: () => never[];
        };
        vertical: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: NumberConstructor;
            default: number;
        };
        styleSet: {
            type: PropType<string | VsStepsStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsStepsStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        trackStyleSet: ComputedRef<CSSProperties>;
        progressStyleSet: ComputedRef<CSSProperties>;
        getStepStyleSet: (index: number) => CSSProperties;
        getLabelStyleSet: (index: number) => CSSProperties;
        selectedIndex: Ref<number, number>;
        isPrevious: (index: number) => boolean;
        isSelected: (index: number) => boolean;
        isDisabled: (index: number) => boolean;
        selectStep: (index: number) => void;
        handleKeydown: (e: KeyboardEvent, isVertical: boolean) => void;
        stepRefs: Ref<HTMLElement[], HTMLElement[]>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('change' | 'update:modelValue')[],
    'change' | 'update:modelValue',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            disabled: {
                type: PropType<boolean | ((step: string, index: number) => boolean)>;
                default: boolean;
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            noLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            steps: {
                type: PropType<string[]>;
                default: () => never[];
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: NumberConstructor;
                default: number;
            };
            styleSet: {
                type: PropType<string | VsStepsStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>
    > &
        Readonly<{
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        disabled: boolean | ((step: string, index: number) => boolean);
        noLabel: boolean;
        vertical: boolean;
        modelValue: number;
        steps: string[];
    },
    {},
    {
        VsResponsive: DefineComponent<
            ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                responsiveClasses: ComputedRef<string[]>;
                responsiveStyles: ComputedRef<Record<string, string>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsStepsRef extends ComponentPublicInstance<typeof VsSteps> {}

export declare interface VsStepsStyleSet extends CSSProperties {
    $stepSize?: string;
    $steps?: CSSProperties;
    $step?: CSSProperties & {
        $completed?: CSSProperties;
        $active?: CSSProperties;
    };
    $label?: CSSProperties & {
        $completed?: CSSProperties;
        $active?: CSSProperties;
    };
    $progress?: CSSProperties & {
        $active?: CSSProperties;
    };
}

export declare const VsSwitch: DefineComponent<
    ExtractPropTypes<{
        beforeChange: {
            type: PropType<(from: any, to: any) => Promise<boolean> | null>;
            default: null;
        };
        checked: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        falseLabel: {
            type: StringConstructor;
            default: string;
        };
        falseValue: {
            type: null;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        trueLabel: {
            type: StringConstructor;
            default: string;
        };
        trueValue: {
            type: null;
            default: boolean;
        };
        modelValue: {
            type: null;
            default: boolean;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<any>[]>;
            default: () => Message<any>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<any>[]>;
            default: () => Rule<any>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
        styleSet: {
            type: PropType<string | VsSwitchStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        switchRef: Readonly<ShallowRef<HTMLInputElement | null>>;
        colorSchemeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            [x: string]: boolean;
            'vs-checked': boolean;
            'vs-disabled': boolean;
            'vs-readonly': boolean;
        }>;
        stateBoxClasses: ComputedRef<{}>;
        computedId: ComputedRef<string>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        computedState: ComputedRef<UIState>;
        componentStyleSet: ComputedRef<Partial<VsSwitchStyleSet>>;
        inputValue: Ref<any, any>;
        isChecked: ComputedRef<boolean>;
        shake: Ref<boolean, boolean>;
        getSwitchButtonStyle: () => CSSProperties;
        onChange: () => Promise<void>;
        onFocus: (e: FocusEvent) => void;
        onBlur: (e: FocusEvent) => void;
        validate: () => boolean;
        clear: () => void;
        reset: () => void;
        focus: () => void;
        blur: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
    'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            beforeChange: {
                type: PropType<(from: any, to: any) => Promise<boolean> | null>;
                default: null;
            };
            checked: {
                type: BooleanConstructor;
                default: boolean;
            };
            multiple: {
                type: BooleanConstructor;
                default: boolean;
            };
            falseLabel: {
                type: StringConstructor;
                default: string;
            };
            falseValue: {
                type: null;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            trueLabel: {
                type: StringConstructor;
                default: string;
            };
            trueValue: {
                type: null;
                default: boolean;
            };
            modelValue: {
                type: null;
                default: boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<any>[]>;
                default: () => Message<any>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<any>[]>;
                default: () => Rule<any>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
            styleSet: {
                type: PropType<string | VsSwitchStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        messages: Message<any>[];
        name: string;
        noDefaultRules: boolean;
        readonly: boolean;
        rules: Rule<any>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        multiple: boolean;
        modelValue: any;
        beforeChange: (from: any, to: any) => Promise<boolean> | null;
        checked: boolean;
        trueValue: any;
        falseValue: any;
        falseLabel: string;
        trueLabel: string;
    },
    {},
    {
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsSwitchRef extends ComponentPublicInstance<typeof VsSwitch>, FocusableRef, FormChildRef {}

export declare interface VsSwitchStyleSet extends CSSProperties {
    $handleColor?: string;
    $handleSize?: string;
    $switchButton?: CSSProperties & {
        $active?: CSSProperties;
    };
    $wrapper?: VsInputWrapperStyleSet;
}

export declare const VsTable: DefineComponent<
    ExtractPropTypes<{
        columns: {
            type: PropType<VsTableColumnDef[] | string[]>;
            default: () => never[];
        };
        items: {
            type: PropType<VsTableItem[]>;
            default: () => never[];
            validator: (value: VsTableItem[]) => boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        responsive: {
            type: BooleanConstructor;
            default: boolean;
        };
        noVirtualScroll: {
            type: BooleanConstructor;
            default: boolean;
        };
        stickyHeader: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        serverMode: {
            type: BooleanConstructor;
            default: boolean;
            validator: (serverMode: boolean, props: unknown) => boolean;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        selectable: {
            type: PropType<boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean)>;
            default: boolean;
        };
        expandable: {
            type: PropType<boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean)>;
            default: boolean;
        };
        state: {
            type: PropType<UIState | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => UIState)>;
            default: string;
        };
        pagination: {
            type: PropType<boolean | VsTablePaginationOptions>;
            default: boolean;
        };
        selectedItems: {
            type: PropType<VsTableItem[]>;
            default: () => VsTableItem[];
            validator: (value: VsTableItem[]) => boolean;
        };
        page: {
            type: PropType<number>;
        };
        pageSize: {
            type: PropType<number>;
            validator: (value: number, props: unknown) => boolean;
        };
        pagedItems: {
            type: PropType<VsTableItem[]>;
            default: () => never[];
        };
        totalItems: {
            type: PropType<VsTableItem[]>;
            default: () => never[];
            validator: (value: VsTableItem[]) => boolean;
        };
        search: {
            type: PropType<SearchProps>;
            default: boolean;
            validator: (value: SearchProps) => boolean;
        };
        styleSet: {
            type: PropType<string | VsTableStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        TABLE_DRAG_WRAPPER_CLASS: string;
        bodyId: ComputedRef<string>;
        colorSchemeClass: ComputedRef<string>;
        computedColorScheme: ComputedRef<
            | 'brown'
            | 'red'
            | 'orange'
            | 'amber'
            | 'yellow'
            | 'lime'
            | 'green'
            | 'emerald'
            | 'teal'
            | 'cyan'
            | 'sky'
            | 'blue'
            | 'indigo'
            | 'violet'
            | 'purple'
            | 'fuchsia'
            | 'pink'
            | 'rose'
            | 'gray'
            | 'none'
            | undefined
        >;
        componentStyleSet: ComputedRef<Partial<VsTableStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            [x: string]: boolean;
            'vs-responsive': boolean;
            'vs-primary': boolean;
        }>;
        headerSentinelRef: Readonly<ShallowRef<HTMLDivElement | null>>;
        contentTableRef: Readonly<ShallowRef<HTMLTableElement | null>>;
        scrollWrapperRef: Readonly<ShallowRef<HTMLDivElement | null>>;
        stickyScrollRef: Readonly<ShallowRef<HTMLDivElement | null>>;
        headerSlots: ComputedRef<string[]>;
        bodySlots: ComputedRef<string[]>;
        useStickyHeader: ComputedRef<boolean>;
        searchOptions: ComputedRef<{
            useRegex?: boolean;
            useCaseSensitive?: boolean;
            placeholder?: string;
        }>;
        tableColumnStyle: ComputedRef<{
            gridTemplateColumns: string;
        }>;
        stickyTableColumnStyle: ComputedRef<{
            gridTemplateColumns: string;
        }>;
        table: TableComposable;
        totalPages: ComputedRef<number>;
        clickCell: (cell: VsTableBodyCell, event: MouseEvent) => void;
        clickRow: (item: VsTableItem, index: number, event: MouseEvent) => void;
        selectRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
        expandRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
        searchRows: (searchText: string) => void;
        dragRow: (event: SortableEvent) => void;
        updateSelectedItems: (items: VsTableItem[]) => void;
        updatePage: (page: number) => void;
        updatePageSize: (pageSize: number) => void;
        expand: (index: number) => void;
        collapse: (index: number) => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    (
        | 'search'
        | 'drag'
        | 'expand-row'
        | 'select-row'
        | 'click-cell'
        | 'click-row'
        | 'paginate'
        | 'update:selectedItems'
        | 'update:page'
        | 'update:pageSize'
        | 'update:pagedItems'
        | 'update:totalItems'
    )[],
    | 'search'
    | 'drag'
    | 'expand-row'
    | 'select-row'
    | 'click-cell'
    | 'click-row'
    | 'paginate'
    | 'update:selectedItems'
    | 'update:page'
    | 'update:pageSize'
    | 'update:pagedItems'
    | 'update:totalItems',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            columns: {
                type: PropType<VsTableColumnDef[] | string[]>;
                default: () => never[];
            };
            items: {
                type: PropType<VsTableItem[]>;
                default: () => never[];
                validator: (value: VsTableItem[]) => boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            noVirtualScroll: {
                type: BooleanConstructor;
                default: boolean;
            };
            stickyHeader: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            serverMode: {
                type: BooleanConstructor;
                default: boolean;
                validator: (serverMode: boolean, props: unknown) => boolean;
            };
            draggable: {
                type: BooleanConstructor;
                default: boolean;
            };
            selectable: {
                type: PropType<boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean)>;
                default: boolean;
            };
            expandable: {
                type: PropType<boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean)>;
                default: boolean;
            };
            state: {
                type: PropType<UIState | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => UIState)>;
                default: string;
            };
            pagination: {
                type: PropType<boolean | VsTablePaginationOptions>;
                default: boolean;
            };
            selectedItems: {
                type: PropType<VsTableItem[]>;
                default: () => VsTableItem[];
                validator: (value: VsTableItem[]) => boolean;
            };
            page: {
                type: PropType<number>;
            };
            pageSize: {
                type: PropType<number>;
                validator: (value: number, props: unknown) => boolean;
            };
            pagedItems: {
                type: PropType<VsTableItem[]>;
                default: () => never[];
            };
            totalItems: {
                type: PropType<VsTableItem[]>;
                default: () => never[];
                validator: (value: VsTableItem[]) => boolean;
            };
            search: {
                type: PropType<SearchProps>;
                default: boolean;
                validator: (value: SearchProps) => boolean;
            };
            styleSet: {
                type: PropType<string | VsTableStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onDrag?: ((...args: any[]) => any) | undefined;
            onSearch?: ((...args: any[]) => any) | undefined;
            'onExpand-row'?: ((...args: any[]) => any) | undefined;
            'onSelect-row'?: ((...args: any[]) => any) | undefined;
            'onClick-cell'?: ((...args: any[]) => any) | undefined;
            'onClick-row'?: ((...args: any[]) => any) | undefined;
            onPaginate?: ((...args: any[]) => any) | undefined;
            'onUpdate:selectedItems'?: ((...args: any[]) => any) | undefined;
            'onUpdate:page'?: ((...args: any[]) => any) | undefined;
            'onUpdate:pageSize'?: ((...args: any[]) => any) | undefined;
            'onUpdate:pagedItems'?: ((...args: any[]) => any) | undefined;
            'onUpdate:totalItems'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        search: SearchProps;
        state: UIState | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => UIState);
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        columns: string[] | VsTableColumnDef<any>[];
        primary: boolean;
        loading: boolean;
        responsive: boolean;
        items: any[];
        draggable: boolean;
        selectedItems: any[];
        pagination: boolean | VsTablePaginationOptions;
        totalItems: any[];
        noVirtualScroll: boolean;
        stickyHeader: boolean;
        serverMode: boolean;
        selectable: boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean);
        expandable: boolean | ((item: VsTableItem, index?: number, items?: VsTableItem[]) => boolean);
        pagedItems: any[];
    },
    {},
    {
        VsTableHeader: DefineComponent<
            {},
            {
                HEADER_ROW_INDEX: number;
                headerCells: Ref<VsTableHeaderCell[], VsTableHeaderCell[]>;
                findMatchingSlotName: (header: VsTableHeaderCell) => string;
                showExpand: ComputedRef<boolean>;
                clickCell: (cell: VsTableHeaderCell, event: MouseEvent) => void;
                selectRow: (row: VsTableHeaderCell[], event: MouseEvent) => void;
                getSortIcon: (header: VsTableHeaderCell) => Component;
                updateSortType: (headerKey: string) => void;
                columns: ComputedRef<VsTableColumnDef<any>[] | null>;
                headerStyle: ComputedRef<CSSProperties | undefined>;
                getCellStyle: (index: number) => CSSProperties;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('select-row' | 'click-cell')[],
            'select-row' | 'click-cell',
            PublicProps,
            Readonly<{}> &
                Readonly<{
                    'onSelect-row'?: ((...args: any[]) => any) | undefined;
                    'onClick-cell'?: ((...args: any[]) => any) | undefined;
                }>,
            {},
            {},
            {
                VsTableDragCell: DefineComponent<
                    ExtractPropTypes<{
                        cells: {
                            type: PropType<VsTableCell[]>;
                            required: true;
                        };
                    }>,
                    {
                        TABLE_DRAG_HANDLE_CLASS: string;
                        tag: ComputedRef<VsTableTag>;
                        cellTypeClass: ComputedRef<'vs-table-td' | 'vs-table-th'>;
                        cellStyle: ComputedRef<CSSProperties | undefined>;
                        draggable: Ref<boolean | undefined, boolean | undefined> | undefined;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            cells: {
                                type: PropType<VsTableCell[]>;
                                required: true;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {},
                    {},
                    {
                        GripVerticalIcon: LucideIcon;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsTableExpandCell: DefineComponent<
                    ExtractPropTypes<{
                        cells: {
                            type: PropType<VsTableCell[]>;
                            default: () => never[];
                        };
                        rowIdx: {
                            type: NumberConstructor;
                            default: number;
                        };
                    }>,
                    {
                        isVsTableBodyRow: isVsTableBodyRow;
                        isExpandable: (cells: VsTableBodyCell[], rowIdx: number) => boolean;
                        isExpanded: (row: VsTableCell[]) => boolean;
                        expandRow: (cells: VsTableCell[], event: MouseEvent) => void;
                        cellStyle: ComputedRef<CSSProperties | undefined>;
                        loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                        primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                        colorScheme:
                            | ComputedRef<
                                  | 'brown'
                                  | 'red'
                                  | 'orange'
                                  | 'amber'
                                  | 'yellow'
                                  | 'lime'
                                  | 'green'
                                  | 'emerald'
                                  | 'teal'
                                  | 'cyan'
                                  | 'sky'
                                  | 'blue'
                                  | 'indigo'
                                  | 'violet'
                                  | 'purple'
                                  | 'fuchsia'
                                  | 'pink'
                                  | 'rose'
                                  | 'gray'
                                  | 'none'
                                  | undefined
                              >
                            | undefined;
                        buttonSize: ComputedRef<'xs' | 'sm' | 'md' | 'lg' | 'xl'>;
                        expandButtonStyleSet: ComputedRef<{
                            $content: {
                                padding: string;
                            };
                            border: string;
                            width: string;
                            height: string;
                            backgroundColor: string;
                            color: string;
                        }>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    'expand-row'[],
                    'expand-row',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            cells: {
                                type: PropType<VsTableCell[]>;
                                default: () => never[];
                            };
                            rowIdx: {
                                type: NumberConstructor;
                                default: number;
                            };
                        }>
                    > &
                        Readonly<{
                            'onExpand-row'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        cells: VsTableCell<any>[];
                        rowIdx: number;
                    },
                    {},
                    {
                        VsButton: DefineComponent<
                            ExtractPropTypes<{
                                circle: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                responsive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<'button' | 'submit' | 'reset'>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsButtonStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                colorSchemeClass: ComputedRef<string>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                                classObj: ComputedRef<{
                                    [x: string]: boolean;
                                    'vs-focus-visible': boolean;
                                    'vs-circle': boolean;
                                    'vs-disabled': boolean;
                                    'vs-ghost': boolean;
                                    'vs-loading-state': boolean;
                                    'vs-outline': boolean;
                                    'vs-primary': boolean;
                                    'vs-responsive': boolean;
                                }>;
                                buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    circle: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    ghost: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    loading: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    outline: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    primary: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    responsive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    type: {
                                        type: PropType<'button' | 'submit' | 'reset'>;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsButtonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                circle: boolean;
                                disabled: boolean;
                                type: 'button' | 'reset' | 'submit';
                                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                outline: boolean;
                                primary: boolean;
                                ghost: boolean;
                                loading: boolean;
                                responsive: boolean;
                            },
                            {},
                            {
                                VsLoading: DefineComponent<
                                    ExtractPropTypes<{
                                        width: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        height: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        styleSet: {
                                            type: PropType<string | VsLoadingStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>,
                                    {
                                        colorSchemeClass: ComputedRef<string>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            width: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            styleSet: {
                                                type: PropType<string | VsLoadingStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {},
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        ChevronDownIcon: LucideIcon;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsTableCheckboxCell: DefineComponent<
                    ExtractPropTypes<{
                        cells: {
                            type: PropType<VsTableCell[]>;
                            default: () => never[];
                        };
                        rowIdx: {
                            type: NumberConstructor;
                            required: true;
                        };
                    }>,
                    {
                        HEADER_ROW_INDEX: number;
                        isBodyRow: isVsTableBodyRow;
                        getRowItem: typeof getRowItem;
                        isSelected: (row: VsTableCell[]) => boolean;
                        isRowSelectable: (row: VsTableCell[], rowIdx: number) => boolean;
                        selectRow: (row: VsTableCell[], event: MouseEvent) => void;
                        anySelectable: ComputedRef<boolean>;
                        selectedItems: Ref<any[], any[]>;
                        selectedAll: ComputedRef<boolean>;
                        selectedPartial: ComputedRef<boolean>;
                        cellStyle: ComputedRef<CSSProperties | undefined>;
                        loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                        primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                        headerCheckboxStyle: ComputedRef<VsCheckboxStyleSet>;
                        colorScheme:
                            | ComputedRef<
                                  | 'brown'
                                  | 'red'
                                  | 'orange'
                                  | 'amber'
                                  | 'yellow'
                                  | 'lime'
                                  | 'green'
                                  | 'emerald'
                                  | 'teal'
                                  | 'cyan'
                                  | 'sky'
                                  | 'blue'
                                  | 'indigo'
                                  | 'violet'
                                  | 'purple'
                                  | 'fuchsia'
                                  | 'pink'
                                  | 'rose'
                                  | 'gray'
                                  | 'none'
                                  | undefined
                              >
                            | undefined;
                        size: Ref<'xs' | 'sm' | 'md' | 'lg' | 'xl', 'xs' | 'sm' | 'md' | 'lg' | 'xl'> | undefined;
                        columns: ComputedRef<VsTableColumnDef<any>[] | null>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    'select-row'[],
                    'select-row',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            cells: {
                                type: PropType<VsTableCell[]>;
                                default: () => never[];
                            };
                            rowIdx: {
                                type: NumberConstructor;
                                required: true;
                            };
                        }>
                    > &
                        Readonly<{
                            'onSelect-row'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        cells: VsTableCell<any>[];
                    },
                    {},
                    {
                        VsCheckbox: DefineComponent<
                            ExtractPropTypes<{
                                beforeChange: {
                                    type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                    default: null;
                                };
                                checked: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                checkLabel: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                indeterminate: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                multiple: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                trueValue: {
                                    type: null;
                                    default: boolean;
                                };
                                falseValue: {
                                    type: null;
                                    default: boolean;
                                };
                                modelValue: {
                                    type: null;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                messages: {
                                    type: PropType<Message<any>[]>;
                                    default: () => Message<any>[];
                                };
                                name: {
                                    type: typeof String;
                                    default: string;
                                };
                                noDefaultRules: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                readonly: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                rules: {
                                    type: PropType<Rule<any>[]>;
                                    default: () => Rule<any>[];
                                };
                                state: {
                                    type: PropType<UIState>;
                                    default: UIState;
                                };
                                changed: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                valid: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsCheckboxStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                                colorSchemeClass: ComputedRef<string>;
                                componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                                classObj: ComputedRef<{
                                    'vs-checked': boolean;
                                    'vs-disabled': boolean;
                                    'vs-focus-visible': boolean;
                                    'vs-indeterminate': boolean;
                                    'vs-readonly': boolean;
                                }>;
                                sizeClass: ComputedRef<string>;
                                stateBoxClasses: ComputedRef<{}>;
                                computedId: ComputedRef<string>;
                                computedDisabled: ComputedRef<boolean>;
                                computedReadonly: ComputedRef<boolean>;
                                computedMessages: ComputedRef<StateMessage<UIState>[]>;
                                computedState: ComputedRef<UIState>;
                                convertToString: (value: any) => string;
                                inputValue: Ref<any, any>;
                                isChecked: ComputedRef<boolean>;
                                shake: Ref<boolean, boolean>;
                                toggle: (e: MouseEvent) => Promise<void>;
                                onFocus: (e: FocusEvent) => void;
                                onBlur: (e: FocusEvent) => void;
                                validate: () => boolean;
                                clear: () => void;
                                reset: () => void;
                                focus: () => void;
                                blur: () => void;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            (
                                | 'blur'
                                | 'change'
                                | 'focus'
                                | 'toggle'
                                | 'clear'
                                | 'update:modelValue'
                                | 'update:changed'
                                | 'update:valid'
                            )[],
                            | 'blur'
                            | 'change'
                            | 'focus'
                            | 'toggle'
                            | 'clear'
                            | 'update:modelValue'
                            | 'update:changed'
                            | 'update:valid',
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    beforeChange: {
                                        type: PropType<
                                            (from: any, to: any, optionValue: any) => Promise<boolean> | null
                                        >;
                                        default: null;
                                    };
                                    checked: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    checkLabel: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    indeterminate: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    multiple: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    trueValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    falseValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    modelValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    messages: {
                                        type: PropType<Message<any>[]>;
                                        default: () => Message<any>[];
                                    };
                                    name: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noDefaultRules: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    readonly: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    rules: {
                                        type: PropType<Rule<any>[]>;
                                        default: () => Rule<any>[];
                                    };
                                    state: {
                                        type: PropType<UIState>;
                                        default: UIState;
                                    };
                                    changed: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    valid: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsCheckboxStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{
                                    onFocus?: ((...args: any[]) => any) | undefined;
                                    onBlur?: ((...args: any[]) => any) | undefined;
                                    onChange?: ((...args: any[]) => any) | undefined;
                                    onToggle?: ((...args: any[]) => any) | undefined;
                                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                    onClear?: ((...args: any[]) => any) | undefined;
                                    'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                    'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                                }>,
                            {
                                label: string;
                                messages: Message<any>[];
                                name: string;
                                noDefaultRules: boolean;
                                readonly: boolean;
                                rules: Rule<any>[];
                                state: UIState;
                                changed: boolean;
                                valid: boolean;
                                disabled: boolean;
                                hidden: boolean;
                                id: string;
                                noLabel: boolean;
                                noMessages: boolean;
                                required: boolean;
                                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                multiple: boolean;
                                modelValue: any;
                                beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                                checked: boolean;
                                checkLabel: string;
                                indeterminate: boolean;
                                trueValue: any;
                                falseValue: any;
                            },
                            {},
                            {
                                VsInputWrapper: DefineComponent<
                                    ExtractPropTypes<{
                                        groupLabel: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        messages: {
                                            type: PropType<StateMessage<UIState>[]>;
                                            default: () => never[];
                                        };
                                        shake: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsInputWrapperStyleSet>;
                                        };
                                        disabled: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        hidden: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        id: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        label: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noLabel: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        noMessages: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        required: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>,
                                    {
                                        needToShake: Ref<boolean, boolean>;
                                        componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            groupLabel: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            messages: {
                                                type: PropType<StateMessage<UIState>[]>;
                                                default: () => never[];
                                            };
                                            shake: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsInputWrapperStyleSet>;
                                            };
                                            disabled: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            hidden: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            id: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            label: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noLabel: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            noMessages: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            required: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        label: string;
                                        messages: StateMessage<UIState>[];
                                        disabled: boolean;
                                        hidden: boolean;
                                        id: string;
                                        noLabel: boolean;
                                        noMessages: boolean;
                                        required: boolean;
                                        groupLabel: boolean;
                                        shake: boolean;
                                    },
                                    {},
                                    {
                                        VsResponsive: DefineComponent<
                                            ExtractPropTypes<{
                                                tag: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                            }>,
                                            {
                                                responsiveClasses: ComputedRef<string[]>;
                                                responsiveStyles: ComputedRef<Record<string, string>>;
                                            },
                                            {},
                                            {},
                                            {},
                                            ComponentOptionsMixin,
                                            ComponentOptionsMixin,
                                            {},
                                            string,
                                            PublicProps,
                                            Readonly<
                                                ExtractPropTypes<{
                                                    tag: {
                                                        type: StringConstructor;
                                                        default: string;
                                                    };
                                                    width: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                    grid: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                }>
                                            > &
                                                Readonly<{}>,
                                            {
                                                tag: string;
                                            },
                                            {},
                                            {},
                                            {},
                                            string,
                                            ComponentProvideOptions,
                                            true,
                                            {},
                                            any
                                        >;
                                        VsMessage: DefineComponent<
                                            ExtractPropTypes<{
                                                state: {
                                                    type: PropType<UIState>;
                                                    default: string;
                                                };
                                                text: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsMessageStyleSet>;
                                                };
                                            }>,
                                            {
                                                colorClass: ComputedRef<
                                                    | 'vs-cs-blue'
                                                    | 'vs-cs-green'
                                                    | 'vs-cs-amber'
                                                    | 'vs-cs-red'
                                                    | 'vs-cs-default'
                                                >;
                                                icon: ComputedRef<Component>;
                                                styleSetVariables: ComputedRef<Record<string, string>>;
                                                componentInlineStyle: ComputedRef<CSSProperties>;
                                            },
                                            {},
                                            {},
                                            {},
                                            ComponentOptionsMixin,
                                            ComponentOptionsMixin,
                                            {},
                                            string,
                                            PublicProps,
                                            Readonly<
                                                ExtractPropTypes<{
                                                    state: {
                                                        type: PropType<UIState>;
                                                        default: string;
                                                    };
                                                    text: {
                                                        type: StringConstructor;
                                                        default: string;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsMessageStyleSet>;
                                                    };
                                                }>
                                            > &
                                                Readonly<{}>,
                                            {
                                                text: string;
                                                state: UIState;
                                            },
                                            {},
                                            {},
                                            {},
                                            string,
                                            ComponentProvideOptions,
                                            true,
                                            {},
                                            any
                                        >;
                                    },
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsTableBody: DefineComponent<
            ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    default: string;
                };
            }>,
            {
                DEFAULT_SORTABLE_OPTIONS: Partial<Options>;
                TABLE_DRAG_WRAPPER_CLASS: string;
                bodySlots: ComputedRef<string[]>;
                colorScheme:
                    | ComputedRef<
                          | 'brown'
                          | 'red'
                          | 'orange'
                          | 'amber'
                          | 'yellow'
                          | 'lime'
                          | 'green'
                          | 'emerald'
                          | 'teal'
                          | 'cyan'
                          | 'sky'
                          | 'blue'
                          | 'indigo'
                          | 'violet'
                          | 'purple'
                          | 'fuchsia'
                          | 'pink'
                          | 'rose'
                          | 'gray'
                          | 'none'
                          | undefined
                      >
                    | undefined;
                displayedBodyCells: WritableComputedRef<VsTableBodyCell<any>[][], VsTableBodyCell<any>[][]>;
                loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                clickCell: (cell: VsTableBodyCell, event: MouseEvent) => void;
                clickRow: (item: VsTableBodyCell['item'], index: number, event: MouseEvent) => void;
                getRowItem: typeof getRowItem;
                getRowId: getRowId;
                selectRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
                expandRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
                handleDragUpdate: (event: SortableEvent) => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('drag' | 'expand-row' | 'select-row' | 'click-cell' | 'click-row')[],
            'drag' | 'expand-row' | 'select-row' | 'click-cell' | 'click-row',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    id: {
                        type: StringConstructor;
                        default: string;
                    };
                }>
            > &
                Readonly<{
                    onDrag?: ((...args: any[]) => any) | undefined;
                    'onExpand-row'?: ((...args: any[]) => any) | undefined;
                    'onSelect-row'?: ((...args: any[]) => any) | undefined;
                    'onClick-cell'?: ((...args: any[]) => any) | undefined;
                    'onClick-row'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                id: string;
            },
            {},
            {
                VsLoading: DefineComponent<
                    ExtractPropTypes<{
                        width: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        styleSet: {
                            type: PropType<string | VsLoadingStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {},
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsTableBodyRow: DefineComponent<
                    ExtractPropTypes<{
                        cells: {
                            type: PropType<VsTableBodyCell[]>;
                            required: true;
                        };
                        rowIdx: {
                            type: NumberConstructor;
                            required: true;
                        };
                    }>,
                    {
                        anyExpandable: ComputedRef<boolean>;
                        colorScheme:
                            | ComputedRef<
                                  | 'brown'
                                  | 'red'
                                  | 'orange'
                                  | 'amber'
                                  | 'yellow'
                                  | 'lime'
                                  | 'green'
                                  | 'emerald'
                                  | 'teal'
                                  | 'cyan'
                                  | 'sky'
                                  | 'blue'
                                  | 'indigo'
                                  | 'violet'
                                  | 'purple'
                                  | 'fuchsia'
                                  | 'pink'
                                  | 'rose'
                                  | 'gray'
                                  | 'none'
                                  | undefined
                              >
                            | undefined;
                        loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                        classObj: ComputedRef<{
                            'vs-selected': boolean;
                        }>;
                        rowStyle: ComputedRef<CSSProperties | undefined>;
                        showExpand: ComputedRef<boolean>;
                        getCellStyle: (index: number) => CSSProperties;
                        stateClasses: ComputedRef<
                            | {
                                  'vs-stated'?: undefined;
                              }
                            | {
                                  [x: string]: true;
                                  'vs-stated': true;
                              }
                        >;
                        clickCell: (cell: VsTableBodyCell, event: MouseEvent) => void;
                        findMatchingSlotName: (cell: VsTableBodyCell) => string;
                        selectRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
                        expandRow: (row: VsTableBodyCell[], event: MouseEvent) => void;
                        getHeaderLabel: (colIdx: number, fallback: string) => string;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    ('expand-row' | 'select-row' | 'click-cell' | 'click-row')[],
                    'expand-row' | 'select-row' | 'click-cell' | 'click-row',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            cells: {
                                type: PropType<VsTableBodyCell[]>;
                                required: true;
                            };
                            rowIdx: {
                                type: NumberConstructor;
                                required: true;
                            };
                        }>
                    > &
                        Readonly<{
                            'onExpand-row'?: ((...args: any[]) => any) | undefined;
                            'onSelect-row'?: ((...args: any[]) => any) | undefined;
                            'onClick-cell'?: ((...args: any[]) => any) | undefined;
                            'onClick-row'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {},
                    {},
                    {
                        VsSkeleton: DefineComponent<
                            ExtractPropTypes<{
                                styleSet: {
                                    type: PropType<string | VsSkeletonStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                colorSchemeClass: ComputedRef<string>;
                                componentStyleSet: ComputedRef<Partial<VsSkeletonStyleSet>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    styleSet: {
                                        type: PropType<string | VsSkeletonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {},
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsTableDragCell: DefineComponent<
                            ExtractPropTypes<{
                                cells: {
                                    type: PropType<VsTableCell[]>;
                                    required: true;
                                };
                            }>,
                            {
                                TABLE_DRAG_HANDLE_CLASS: string;
                                tag: ComputedRef<VsTableTag>;
                                cellTypeClass: ComputedRef<'vs-table-td' | 'vs-table-th'>;
                                cellStyle: ComputedRef<CSSProperties | undefined>;
                                draggable: Ref<boolean | undefined, boolean | undefined> | undefined;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    cells: {
                                        type: PropType<VsTableCell[]>;
                                        required: true;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {},
                            {},
                            {
                                GripVerticalIcon: LucideIcon;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsTableExpandCell: DefineComponent<
                            ExtractPropTypes<{
                                cells: {
                                    type: PropType<VsTableCell[]>;
                                    default: () => never[];
                                };
                                rowIdx: {
                                    type: NumberConstructor;
                                    default: number;
                                };
                            }>,
                            {
                                isVsTableBodyRow: isVsTableBodyRow;
                                isExpandable: (cells: VsTableBodyCell[], rowIdx: number) => boolean;
                                isExpanded: (row: VsTableCell[]) => boolean;
                                expandRow: (cells: VsTableCell[], event: MouseEvent) => void;
                                cellStyle: ComputedRef<CSSProperties | undefined>;
                                loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                                primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                                colorScheme:
                                    | ComputedRef<
                                          | 'brown'
                                          | 'red'
                                          | 'orange'
                                          | 'amber'
                                          | 'yellow'
                                          | 'lime'
                                          | 'green'
                                          | 'emerald'
                                          | 'teal'
                                          | 'cyan'
                                          | 'sky'
                                          | 'blue'
                                          | 'indigo'
                                          | 'violet'
                                          | 'purple'
                                          | 'fuchsia'
                                          | 'pink'
                                          | 'rose'
                                          | 'gray'
                                          | 'none'
                                          | undefined
                                      >
                                    | undefined;
                                buttonSize: ComputedRef<'xs' | 'sm' | 'md' | 'lg' | 'xl'>;
                                expandButtonStyleSet: ComputedRef<{
                                    $content: {
                                        padding: string;
                                    };
                                    border: string;
                                    width: string;
                                    height: string;
                                    backgroundColor: string;
                                    color: string;
                                }>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            'expand-row'[],
                            'expand-row',
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    cells: {
                                        type: PropType<VsTableCell[]>;
                                        default: () => never[];
                                    };
                                    rowIdx: {
                                        type: NumberConstructor;
                                        default: number;
                                    };
                                }>
                            > &
                                Readonly<{
                                    'onExpand-row'?: ((...args: any[]) => any) | undefined;
                                }>,
                            {
                                cells: VsTableCell<any>[];
                                rowIdx: number;
                            },
                            {},
                            {
                                VsButton: DefineComponent<
                                    ExtractPropTypes<{
                                        circle: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        ghost: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        loading: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        outline: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        primary: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        responsive: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        type: {
                                            type: PropType<'button' | 'submit' | 'reset'>;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsButtonStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>,
                                    {
                                        colorSchemeClass: ComputedRef<string>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                        classObj: ComputedRef<{
                                            [x: string]: boolean;
                                            'vs-focus-visible': boolean;
                                            'vs-circle': boolean;
                                            'vs-disabled': boolean;
                                            'vs-ghost': boolean;
                                            'vs-loading-state': boolean;
                                            'vs-outline': boolean;
                                            'vs-primary': boolean;
                                            'vs-responsive': boolean;
                                        }>;
                                        buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                        componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            circle: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            disabled: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            ghost: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            loading: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            outline: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            primary: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            responsive: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            type: {
                                                type: PropType<'button' | 'submit' | 'reset'>;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsButtonStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        circle: boolean;
                                        disabled: boolean;
                                        type: 'button' | 'reset' | 'submit';
                                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                        outline: boolean;
                                        primary: boolean;
                                        ghost: boolean;
                                        loading: boolean;
                                        responsive: boolean;
                                    },
                                    {},
                                    {
                                        VsLoading: DefineComponent<
                                            ExtractPropTypes<{
                                                width: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                height: {
                                                    type: (StringConstructor | NumberConstructor)[];
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsLoadingStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>,
                                            {
                                                colorSchemeClass: ComputedRef<string>;
                                                styleSetVariables: ComputedRef<Record<string, string>>;
                                                componentInlineStyle: ComputedRef<CSSProperties>;
                                            },
                                            {},
                                            {},
                                            {},
                                            ComponentOptionsMixin,
                                            ComponentOptionsMixin,
                                            {},
                                            string,
                                            PublicProps,
                                            Readonly<
                                                ExtractPropTypes<{
                                                    width: {
                                                        type: (StringConstructor | NumberConstructor)[];
                                                    };
                                                    height: {
                                                        type: (StringConstructor | NumberConstructor)[];
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsLoadingStyleSet>;
                                                    };
                                                    colorScheme: {
                                                        type: PropType<ColorScheme>;
                                                    };
                                                }>
                                            > &
                                                Readonly<{}>,
                                            {},
                                            {},
                                            {},
                                            {},
                                            string,
                                            ComponentProvideOptions,
                                            true,
                                            {},
                                            any
                                        >;
                                    },
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                                ChevronDownIcon: LucideIcon;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsTableExpandedPanel: DefineComponent<
                            ExtractPropTypes<{
                                cells: {
                                    type: PropType<VsTableBodyCell[]>;
                                    required: true;
                                };
                                rowIdx: {
                                    type: NumberConstructor;
                                    required: true;
                                };
                            }>,
                            {
                                isExpanded: (row: VsTableCell[]) => boolean;
                                size:
                                    | Ref<
                                          'xs' | 'sm' | 'md' | 'lg' | 'xl' | undefined,
                                          'xs' | 'sm' | 'md' | 'lg' | 'xl' | undefined
                                      >
                                    | undefined;
                                getRowItem: typeof getRowItem;
                                expandableStyleSet: ComputedRef<VsExpandableStyleSet>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    cells: {
                                        type: PropType<VsTableBodyCell[]>;
                                        required: true;
                                    };
                                    rowIdx: {
                                        type: NumberConstructor;
                                        required: true;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {},
                            {},
                            {
                                VsExpandable: DefineComponent<
                                    ExtractPropTypes<{
                                        open: {
                                            type: BooleanConstructor;
                                            required: true;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsExpandableStyleSet>;
                                        };
                                    }>,
                                    {
                                        sizeClass: ComputedRef<string>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                        beforeEnter: (el: Element) => void;
                                        enter: (el: Element, done: () => void) => void;
                                        beforeLeave: (el: Element) => void;
                                        leave: (el: Element, done: () => void) => void;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            open: {
                                                type: BooleanConstructor;
                                                required: true;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsExpandableStyleSet>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                    },
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsTableCheckboxCell: DefineComponent<
                            ExtractPropTypes<{
                                cells: {
                                    type: PropType<VsTableCell[]>;
                                    default: () => never[];
                                };
                                rowIdx: {
                                    type: NumberConstructor;
                                    required: true;
                                };
                            }>,
                            {
                                HEADER_ROW_INDEX: number;
                                isBodyRow: isVsTableBodyRow;
                                getRowItem: typeof getRowItem;
                                isSelected: (row: VsTableCell[]) => boolean;
                                isRowSelectable: (row: VsTableCell[], rowIdx: number) => boolean;
                                selectRow: (row: VsTableCell[], event: MouseEvent) => void;
                                anySelectable: ComputedRef<boolean>;
                                selectedItems: Ref<any[], any[]>;
                                selectedAll: ComputedRef<boolean>;
                                selectedPartial: ComputedRef<boolean>;
                                cellStyle: ComputedRef<CSSProperties | undefined>;
                                loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                                primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                                headerCheckboxStyle: ComputedRef<VsCheckboxStyleSet>;
                                colorScheme:
                                    | ComputedRef<
                                          | 'brown'
                                          | 'red'
                                          | 'orange'
                                          | 'amber'
                                          | 'yellow'
                                          | 'lime'
                                          | 'green'
                                          | 'emerald'
                                          | 'teal'
                                          | 'cyan'
                                          | 'sky'
                                          | 'blue'
                                          | 'indigo'
                                          | 'violet'
                                          | 'purple'
                                          | 'fuchsia'
                                          | 'pink'
                                          | 'rose'
                                          | 'gray'
                                          | 'none'
                                          | undefined
                                      >
                                    | undefined;
                                size:
                                    | Ref<'xs' | 'sm' | 'md' | 'lg' | 'xl', 'xs' | 'sm' | 'md' | 'lg' | 'xl'>
                                    | undefined;
                                columns: ComputedRef<VsTableColumnDef<any>[] | null>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            'select-row'[],
                            'select-row',
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    cells: {
                                        type: PropType<VsTableCell[]>;
                                        default: () => never[];
                                    };
                                    rowIdx: {
                                        type: NumberConstructor;
                                        required: true;
                                    };
                                }>
                            > &
                                Readonly<{
                                    'onSelect-row'?: ((...args: any[]) => any) | undefined;
                                }>,
                            {
                                cells: VsTableCell<any>[];
                            },
                            {},
                            {
                                VsCheckbox: DefineComponent<
                                    ExtractPropTypes<{
                                        beforeChange: {
                                            type: PropType<
                                                (from: any, to: any, optionValue: any) => Promise<boolean> | null
                                            >;
                                            default: null;
                                        };
                                        checked: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        checkLabel: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        indeterminate: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        multiple: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        trueValue: {
                                            type: null;
                                            default: boolean;
                                        };
                                        falseValue: {
                                            type: null;
                                            default: boolean;
                                        };
                                        modelValue: {
                                            type: null;
                                            default: boolean;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        label: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        messages: {
                                            type: PropType<Message<any>[]>;
                                            default: () => Message<any>[];
                                        };
                                        name: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noDefaultRules: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        readonly: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        rules: {
                                            type: PropType<Rule<any>[]>;
                                            default: () => Rule<any>[];
                                        };
                                        state: {
                                            type: PropType<UIState>;
                                            default: UIState;
                                        };
                                        changed: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        valid: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        hidden: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        id: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noLabel: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        noMessages: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        required: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsCheckboxStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>,
                                    {
                                        checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                                        colorSchemeClass: ComputedRef<string>;
                                        componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                        classObj: ComputedRef<{
                                            'vs-checked': boolean;
                                            'vs-disabled': boolean;
                                            'vs-focus-visible': boolean;
                                            'vs-indeterminate': boolean;
                                            'vs-readonly': boolean;
                                        }>;
                                        sizeClass: ComputedRef<string>;
                                        stateBoxClasses: ComputedRef<{}>;
                                        computedId: ComputedRef<string>;
                                        computedDisabled: ComputedRef<boolean>;
                                        computedReadonly: ComputedRef<boolean>;
                                        computedMessages: ComputedRef<StateMessage<UIState>[]>;
                                        computedState: ComputedRef<UIState>;
                                        convertToString: (value: any) => string;
                                        inputValue: Ref<any, any>;
                                        isChecked: ComputedRef<boolean>;
                                        shake: Ref<boolean, boolean>;
                                        toggle: (e: MouseEvent) => Promise<void>;
                                        onFocus: (e: FocusEvent) => void;
                                        onBlur: (e: FocusEvent) => void;
                                        validate: () => boolean;
                                        clear: () => void;
                                        reset: () => void;
                                        focus: () => void;
                                        blur: () => void;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    (
                                        | 'blur'
                                        | 'change'
                                        | 'focus'
                                        | 'toggle'
                                        | 'clear'
                                        | 'update:modelValue'
                                        | 'update:changed'
                                        | 'update:valid'
                                    )[],
                                    | 'blur'
                                    | 'change'
                                    | 'focus'
                                    | 'toggle'
                                    | 'clear'
                                    | 'update:modelValue'
                                    | 'update:changed'
                                    | 'update:valid',
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            beforeChange: {
                                                type: PropType<
                                                    (from: any, to: any, optionValue: any) => Promise<boolean> | null
                                                >;
                                                default: null;
                                            };
                                            checked: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            checkLabel: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            indeterminate: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            multiple: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            trueValue: {
                                                type: null;
                                                default: boolean;
                                            };
                                            falseValue: {
                                                type: null;
                                                default: boolean;
                                            };
                                            modelValue: {
                                                type: null;
                                                default: boolean;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            label: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            messages: {
                                                type: PropType<Message<any>[]>;
                                                default: () => Message<any>[];
                                            };
                                            name: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noDefaultRules: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            readonly: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            rules: {
                                                type: PropType<Rule<any>[]>;
                                                default: () => Rule<any>[];
                                            };
                                            state: {
                                                type: PropType<UIState>;
                                                default: UIState;
                                            };
                                            changed: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            valid: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            disabled: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            hidden: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            id: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noLabel: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            noMessages: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            required: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsCheckboxStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>
                                    > &
                                        Readonly<{
                                            onFocus?: ((...args: any[]) => any) | undefined;
                                            onBlur?: ((...args: any[]) => any) | undefined;
                                            onChange?: ((...args: any[]) => any) | undefined;
                                            onToggle?: ((...args: any[]) => any) | undefined;
                                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                            onClear?: ((...args: any[]) => any) | undefined;
                                            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                                        }>,
                                    {
                                        label: string;
                                        messages: Message<any>[];
                                        name: string;
                                        noDefaultRules: boolean;
                                        readonly: boolean;
                                        rules: Rule<any>[];
                                        state: UIState;
                                        changed: boolean;
                                        valid: boolean;
                                        disabled: boolean;
                                        hidden: boolean;
                                        id: string;
                                        noLabel: boolean;
                                        noMessages: boolean;
                                        required: boolean;
                                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                        multiple: boolean;
                                        modelValue: any;
                                        beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                                        checked: boolean;
                                        checkLabel: string;
                                        indeterminate: boolean;
                                        trueValue: any;
                                        falseValue: any;
                                    },
                                    {},
                                    {
                                        VsInputWrapper: DefineComponent<
                                            ExtractPropTypes<{
                                                groupLabel: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                messages: {
                                                    type: PropType<StateMessage<UIState>[]>;
                                                    default: () => never[];
                                                };
                                                shake: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsInputWrapperStyleSet>;
                                                };
                                                disabled: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                hidden: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                id: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                label: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                noLabel: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                noMessages: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                required: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                            }>,
                                            {
                                                needToShake: Ref<boolean, boolean>;
                                                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                                componentInlineStyle: ComputedRef<CSSProperties>;
                                            },
                                            {},
                                            {},
                                            {},
                                            ComponentOptionsMixin,
                                            ComponentOptionsMixin,
                                            {},
                                            string,
                                            PublicProps,
                                            Readonly<
                                                ExtractPropTypes<{
                                                    groupLabel: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    messages: {
                                                        type: PropType<StateMessage<UIState>[]>;
                                                        default: () => never[];
                                                    };
                                                    shake: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsInputWrapperStyleSet>;
                                                    };
                                                    disabled: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    hidden: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    id: {
                                                        type: typeof String;
                                                        default: string;
                                                    };
                                                    label: {
                                                        type: typeof String;
                                                        default: string;
                                                    };
                                                    noLabel: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    noMessages: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    required: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    width: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                    grid: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                }>
                                            > &
                                                Readonly<{}>,
                                            {
                                                label: string;
                                                messages: StateMessage<UIState>[];
                                                disabled: boolean;
                                                hidden: boolean;
                                                id: string;
                                                noLabel: boolean;
                                                noMessages: boolean;
                                                required: boolean;
                                                groupLabel: boolean;
                                                shake: boolean;
                                            },
                                            {},
                                            {
                                                VsResponsive: DefineComponent<
                                                    ExtractPropTypes<{
                                                        tag: {
                                                            type: StringConstructor;
                                                            default: string;
                                                        };
                                                        width: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                        grid: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                    }>,
                                                    {
                                                        responsiveClasses: ComputedRef<string[]>;
                                                        responsiveStyles: ComputedRef<Record<string, string>>;
                                                    },
                                                    {},
                                                    {},
                                                    {},
                                                    ComponentOptionsMixin,
                                                    ComponentOptionsMixin,
                                                    {},
                                                    string,
                                                    PublicProps,
                                                    Readonly<
                                                        ExtractPropTypes<{
                                                            tag: {
                                                                type: StringConstructor;
                                                                default: string;
                                                            };
                                                            width: {
                                                                type: PropType<string | number | Breakpoints>;
                                                            };
                                                            grid: {
                                                                type: PropType<string | number | Breakpoints>;
                                                            };
                                                        }>
                                                    > &
                                                        Readonly<{}>,
                                                    {
                                                        tag: string;
                                                    },
                                                    {},
                                                    {},
                                                    {},
                                                    string,
                                                    ComponentProvideOptions,
                                                    true,
                                                    {},
                                                    any
                                                >;
                                                VsMessage: DefineComponent<
                                                    ExtractPropTypes<{
                                                        state: {
                                                            type: PropType<UIState>;
                                                            default: string;
                                                        };
                                                        text: {
                                                            type: StringConstructor;
                                                            default: string;
                                                        };
                                                        styleSet: {
                                                            type: PropType<string | VsMessageStyleSet>;
                                                        };
                                                    }>,
                                                    {
                                                        colorClass: ComputedRef<
                                                            | 'vs-cs-blue'
                                                            | 'vs-cs-green'
                                                            | 'vs-cs-amber'
                                                            | 'vs-cs-red'
                                                            | 'vs-cs-default'
                                                        >;
                                                        icon: ComputedRef<Component>;
                                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                                    },
                                                    {},
                                                    {},
                                                    {},
                                                    ComponentOptionsMixin,
                                                    ComponentOptionsMixin,
                                                    {},
                                                    string,
                                                    PublicProps,
                                                    Readonly<
                                                        ExtractPropTypes<{
                                                            state: {
                                                                type: PropType<UIState>;
                                                                default: string;
                                                            };
                                                            text: {
                                                                type: StringConstructor;
                                                                default: string;
                                                            };
                                                            styleSet: {
                                                                type: PropType<string | VsMessageStyleSet>;
                                                            };
                                                        }>
                                                    > &
                                                        Readonly<{}>,
                                                    {
                                                        text: string;
                                                        state: UIState;
                                                    },
                                                    {},
                                                    {},
                                                    {},
                                                    string,
                                                    ComponentProvideOptions,
                                                    true,
                                                    {},
                                                    any
                                                >;
                                            },
                                            {},
                                            string,
                                            ComponentProvideOptions,
                                            true,
                                            {},
                                            any
                                        >;
                                    },
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                BanIcon: LucideIcon;
                draggable: 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;
                    },
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    any[],
                    any,
                    VNodeProps & AllowedComponentProps & 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,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsSearchInput: DefineComponent<
            ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                placeholder: {
                    type: StringConstructor;
                    default: string;
                };
                readonly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                useCaseSensitive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                useRegex: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modelValue: {
                    type: StringConstructor;
                    default: string;
                };
                caseSensitive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                regex: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
                styleSet: {
                    type: PropType<string | VsSearchInputStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                inputRef: Readonly<ShallowRef<VsInputRef | null>>;
                searchText: Ref<string, string>;
                isCaseSensitiveOn: Ref<boolean, boolean>;
                isRegexOn: Ref<boolean, boolean>;
                computedColorScheme: ComputedRef<
                    | 'brown'
                    | 'red'
                    | 'orange'
                    | 'amber'
                    | 'yellow'
                    | 'lime'
                    | 'green'
                    | 'emerald'
                    | 'teal'
                    | 'cyan'
                    | 'sky'
                    | 'blue'
                    | 'indigo'
                    | 'violet'
                    | 'purple'
                    | 'fuchsia'
                    | 'pink'
                    | 'rose'
                    | 'gray'
                    | 'none'
                    | undefined
                >;
                componentStyleSet: ComputedRef<Partial<VsSearchInputStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                onInputChange: (value: string | number | null) => void;
                match: (text: string) => boolean;
                focus: () => void;
                blur: () => void;
                select: () => void;
                clear: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex')[],
            'search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: string;
                    };
                    readonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    useCaseSensitive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    useRegex: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: string;
                    };
                    caseSensitive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    regex: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    styleSet: {
                        type: PropType<string | VsSearchInputStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                    onSearch?: ((...args: any[]) => any) | undefined;
                    'onUpdate:caseSensitive'?: ((...args: any[]) => any) | undefined;
                    'onUpdate:regex'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                placeholder: string;
                readonly: boolean;
                disabled: boolean;
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                modelValue: string;
                useCaseSensitive: boolean;
                useRegex: boolean;
                caseSensitive: boolean;
                regex: boolean;
            },
            {},
            {
                VsInput: DefineComponent<
                    ExtractPropTypes<{
                        autocomplete: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        noClear: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<VsInputType>;
                            default: string;
                        };
                        modelValue: {
                            type: PropType<VsInputValueType>;
                            default: null;
                        };
                        modelModifiers: {
                            type: PropType<StringModifiers>;
                            default: () => {};
                        };
                        min: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        max: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        styleSet: {
                            type: PropType<string | VsInputStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        messages: {
                            type: PropType<Message<VsInputValueType>[]>;
                            default: () => Message<VsInputValueType>[];
                        };
                        name: {
                            type: typeof String;
                            default: string;
                        };
                        noDefaultRules: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        placeholder: {
                            type: typeof String;
                            default: string;
                        };
                        readonly: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        rules: {
                            type: PropType<Rule<VsInputValueType>[]>;
                            default: () => Rule<VsInputValueType>[];
                        };
                        state: {
                            type: PropType<UIState>;
                            default: UIState;
                        };
                        changed: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        valid: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                    }>,
                    {
                        inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                        classObj: ComputedRef<{
                            [x: string]: boolean;
                            'vs-focus-visible': boolean;
                            'vs-focus-within': boolean;
                            'vs-disabled': boolean;
                            'vs-readonly': boolean;
                        }>;
                        colorSchemeClass: ComputedRef<string>;
                        componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                        inputValue: Ref<VsInputValueType, VsInputValueType>;
                        computedMessages: ComputedRef<StateMessage<UIState>[]>;
                        computedDisabled: ComputedRef<boolean>;
                        computedReadonly: ComputedRef<boolean>;
                        renderClearButton: ComputedRef<boolean>;
                        shake: Ref<boolean, boolean>;
                        stateBoxClasses: ComputedRef<{}>;
                        computedId: ComputedRef<string>;
                        onInput: (event: Event) => void;
                        focus: () => void;
                        blur: () => void;
                        select: () => void;
                        clear: () => void;
                        reset: () => void;
                        onFocus: (e: FocusEvent) => void;
                        onBlur: (e: FocusEvent) => void;
                        validate: () => boolean;
                        clearWithFocus: () => void;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
                    'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            autocomplete: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            noClear: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<VsInputType>;
                                default: string;
                            };
                            modelValue: {
                                type: PropType<VsInputValueType>;
                                default: null;
                            };
                            modelModifiers: {
                                type: PropType<StringModifiers>;
                                default: () => {};
                            };
                            min: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            max: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            styleSet: {
                                type: PropType<string | VsInputStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            messages: {
                                type: PropType<Message<VsInputValueType>[]>;
                                default: () => Message<VsInputValueType>[];
                            };
                            name: {
                                type: typeof String;
                                default: string;
                            };
                            noDefaultRules: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            placeholder: {
                                type: typeof String;
                                default: string;
                            };
                            readonly: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            rules: {
                                type: PropType<Rule<VsInputValueType>[]>;
                                default: () => Rule<VsInputValueType>[];
                            };
                            state: {
                                type: PropType<UIState>;
                                default: UIState;
                            };
                            changed: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            valid: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                        }>
                    > &
                        Readonly<{
                            onFocus?: ((...args: any[]) => any) | undefined;
                            onBlur?: ((...args: any[]) => any) | undefined;
                            onChange?: ((...args: any[]) => any) | undefined;
                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                            onClear?: ((...args: any[]) => any) | undefined;
                            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        label: string;
                        messages: Message<VsInputValueType>[];
                        name: string;
                        noDefaultRules: boolean;
                        placeholder: string;
                        readonly: boolean;
                        rules: Rule<VsInputValueType>[];
                        state: UIState;
                        changed: boolean;
                        valid: boolean;
                        disabled: boolean;
                        hidden: boolean;
                        id: string;
                        noLabel: boolean;
                        noMessages: boolean;
                        required: boolean;
                        min: string | number;
                        max: string | number;
                        type: VsInputType;
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        modelValue: VsInputValueType;
                        autocomplete: boolean;
                        noClear: boolean;
                        modelModifiers: StringModifiers;
                    },
                    {},
                    {
                        VsInputWrapper: DefineComponent<
                            ExtractPropTypes<{
                                groupLabel: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                messages: {
                                    type: PropType<StateMessage<UIState>[]>;
                                    default: () => never[];
                                };
                                shake: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputWrapperStyleSet>;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>,
                            {
                                needToShake: Ref<boolean, boolean>;
                                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    groupLabel: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    messages: {
                                        type: PropType<StateMessage<UIState>[]>;
                                        default: () => never[];
                                    };
                                    shake: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsInputWrapperStyleSet>;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                label: string;
                                messages: StateMessage<UIState>[];
                                disabled: boolean;
                                hidden: boolean;
                                id: string;
                                noLabel: boolean;
                                noMessages: boolean;
                                required: boolean;
                                groupLabel: boolean;
                                shake: boolean;
                            },
                            {},
                            {
                                VsResponsive: DefineComponent<
                                    ExtractPropTypes<{
                                        tag: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>,
                                    {
                                        responsiveClasses: ComputedRef<string[]>;
                                        responsiveStyles: ComputedRef<Record<string, string>>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            tag: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        tag: string;
                                    },
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                                VsMessage: DefineComponent<
                                    ExtractPropTypes<{
                                        state: {
                                            type: PropType<UIState>;
                                            default: string;
                                        };
                                        text: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsMessageStyleSet>;
                                        };
                                    }>,
                                    {
                                        colorClass: ComputedRef<
                                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                        >;
                                        icon: ComputedRef<Component>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            state: {
                                                type: PropType<UIState>;
                                                default: string;
                                            };
                                            text: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsMessageStyleSet>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        text: string;
                                        state: UIState;
                                    },
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        XIcon: LucideIcon;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsToggle: DefineComponent<
                    ExtractPropTypes<{
                        modelValue: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsToggleStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        toggle: () => void;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    ('toggle' | 'update:modelValue')[],
                    'toggle' | 'update:modelValue',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            modelValue: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsToggleStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{
                            onToggle?: ((...args: any[]) => any) | undefined;
                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        circle: boolean;
                        disabled: boolean;
                        type: 'button' | 'reset' | 'submit';
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        outline: boolean;
                        primary: boolean;
                        modelValue: boolean;
                        ghost: boolean;
                        loading: boolean;
                        responsive: boolean;
                    },
                    {},
                    {
                        VsButton: DefineComponent<
                            ExtractPropTypes<{
                                circle: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                responsive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<'button' | 'submit' | 'reset'>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsButtonStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                colorSchemeClass: ComputedRef<string>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                                classObj: ComputedRef<{
                                    [x: string]: boolean;
                                    'vs-focus-visible': boolean;
                                    'vs-circle': boolean;
                                    'vs-disabled': boolean;
                                    'vs-ghost': boolean;
                                    'vs-loading-state': boolean;
                                    'vs-outline': boolean;
                                    'vs-primary': boolean;
                                    'vs-responsive': boolean;
                                }>;
                                buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    circle: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    ghost: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    loading: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    outline: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    primary: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    responsive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    type: {
                                        type: PropType<'button' | 'submit' | 'reset'>;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsButtonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                circle: boolean;
                                disabled: boolean;
                                type: 'button' | 'reset' | 'submit';
                                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                outline: boolean;
                                primary: boolean;
                                ghost: boolean;
                                loading: boolean;
                                responsive: boolean;
                            },
                            {},
                            {
                                VsLoading: DefineComponent<
                                    ExtractPropTypes<{
                                        width: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        height: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        styleSet: {
                                            type: PropType<string | VsLoadingStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>,
                                    {
                                        colorSchemeClass: ComputedRef<string>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            width: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            styleSet: {
                                                type: PropType<string | VsLoadingStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {},
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsTablePagination: DefineComponent<
            {},
            {
                pagination: ComputedRef<VsTablePaginationOptions>;
                page: WritableComputedRef<number, number>;
                pageSize: WritableComputedRef<number, number>;
                pageSizeOptions: ComputedRef<VsTablePageSizeOptions>;
                totalPages: ComputedRef<number>;
                totalItems: ComputedRef<number>;
                pageStartIndex: ComputedRef<number>;
                pageEndIndex: ComputedRef<number>;
                loading: Ref<boolean | undefined, boolean | undefined> | undefined;
                primary: Ref<boolean | undefined, boolean | undefined> | undefined;
                size:
                    | Ref<'xs' | 'sm' | 'md' | 'lg' | 'xl' | undefined, 'xs' | 'sm' | 'md' | 'lg' | 'xl' | undefined>
                    | undefined;
                colorScheme:
                    | ComputedRef<
                          | 'brown'
                          | 'red'
                          | 'orange'
                          | 'amber'
                          | 'yellow'
                          | 'lime'
                          | 'green'
                          | 'emerald'
                          | 'teal'
                          | 'cyan'
                          | 'sky'
                          | 'blue'
                          | 'indigo'
                          | 'violet'
                          | 'purple'
                          | 'fuchsia'
                          | 'pink'
                          | 'rose'
                          | 'gray'
                          | 'none'
                          | undefined
                      >
                    | undefined;
                tableStyleSet: ComputedRef<VsTableStyleSet> | undefined;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<{}> & Readonly<{}>,
            {},
            {},
            {
                VsPagination: DefineComponent<
                    ExtractPropTypes<{
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        edgeButtons: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        length: {
                            type: NumberConstructor;
                            required: true;
                            default: number;
                            validator: (value: number) => boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        showingLength: {
                            type: NumberConstructor;
                            default: number;
                            validator: (value: number) => boolean;
                        };
                        modelValue: {
                            type: NumberConstructor;
                            default: number;
                        };
                        styleSet: {
                            type: PropType<string | VsPaginationStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        computedColorScheme: ComputedRef<
                            | 'brown'
                            | 'red'
                            | 'orange'
                            | 'amber'
                            | 'yellow'
                            | 'lime'
                            | 'green'
                            | 'emerald'
                            | 'teal'
                            | 'cyan'
                            | 'sky'
                            | 'blue'
                            | 'indigo'
                            | 'violet'
                            | 'purple'
                            | 'fuchsia'
                            | 'pink'
                            | 'rose'
                            | 'gray'
                            | 'none'
                            | undefined
                        >;
                        colorSchemeClass: ComputedRef<string>;
                        sizeClass: ComputedRef<string>;
                        componentStyleSet: ComputedRef<Partial<VsPaginationStyleSet>>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                        selectedIndex: Ref<number, number>;
                        pages: ComputedRef<number[]>;
                        getPageButtonStyleSet: (page: number) => Omit<VsButtonStyleSet, '$loading'>;
                        goFirst: () => void;
                        goLast: () => void;
                        goPrev: () => void;
                        goNext: () => void;
                        setPage: (page: number) => void;
                        selectIndex: (index: number) => void;
                        isFirstEdge: ComputedRef<boolean>;
                        isLastEdge: ComputedRef<boolean>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    ('change' | 'update:modelValue')[],
                    'change' | 'update:modelValue',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            edgeButtons: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            length: {
                                type: NumberConstructor;
                                required: true;
                                default: number;
                                validator: (value: number) => boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            showingLength: {
                                type: NumberConstructor;
                                default: number;
                                validator: (value: number) => boolean;
                            };
                            modelValue: {
                                type: NumberConstructor;
                                default: number;
                            };
                            styleSet: {
                                type: PropType<string | VsPaginationStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{
                            onChange?: ((...args: any[]) => any) | undefined;
                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        disabled: boolean;
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        length: number;
                        outline: boolean;
                        modelValue: number;
                        ghost: boolean;
                        edgeButtons: boolean;
                        showingLength: number;
                    },
                    {},
                    {
                        VsButton: DefineComponent<
                            ExtractPropTypes<{
                                circle: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                ghost: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                outline: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                primary: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                responsive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                type: {
                                    type: PropType<'button' | 'submit' | 'reset'>;
                                    default: string;
                                };
                                styleSet: {
                                    type: PropType<string | VsButtonStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                colorSchemeClass: ComputedRef<string>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                                classObj: ComputedRef<{
                                    [x: string]: boolean;
                                    'vs-focus-visible': boolean;
                                    'vs-circle': boolean;
                                    'vs-disabled': boolean;
                                    'vs-ghost': boolean;
                                    'vs-loading-state': boolean;
                                    'vs-outline': boolean;
                                    'vs-primary': boolean;
                                    'vs-responsive': boolean;
                                }>;
                                buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    circle: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    ghost: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    loading: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    outline: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    primary: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    responsive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    type: {
                                        type: PropType<'button' | 'submit' | 'reset'>;
                                        default: string;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsButtonStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                circle: boolean;
                                disabled: boolean;
                                type: 'button' | 'reset' | 'submit';
                                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                outline: boolean;
                                primary: boolean;
                                ghost: boolean;
                                loading: boolean;
                                responsive: boolean;
                            },
                            {},
                            {
                                VsLoading: DefineComponent<
                                    ExtractPropTypes<{
                                        width: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        height: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        styleSet: {
                                            type: PropType<string | VsLoadingStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>,
                                    {
                                        colorSchemeClass: ComputedRef<string>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            width: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            styleSet: {
                                                type: PropType<string | VsLoadingStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {},
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        ChevronFirstIcon: LucideIcon;
                        ChevronLastIcon: LucideIcon;
                        ChevronLeftIcon: LucideIcon;
                        ChevronRightIcon: LucideIcon;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsSelect: DefineComponent<
                    ExtractPropTypes<{
                        closableChips: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        collapseChips: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        multiple: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        noClear: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        optionsDisabled: {
                            type: PropType<boolean | ((option: any, index: number, options: any[]) => boolean)>;
                            default: boolean;
                        };
                        selectAll: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        modelValue: {
                            type: null;
                            default: null;
                        };
                        search: {
                            type: PropType<SearchProps>;
                            default: boolean;
                            validator: (value: SearchProps) => boolean;
                        };
                        min: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        max: {
                            type: PropType<number | string>;
                            default: string | number;
                            validator: (value: number | string) => boolean;
                        };
                        groupBy: {
                            type: PropType<(option: any, index: number) => string | null> | null;
                            default: null;
                        };
                        groupOrder: {
                            type: PropType<string[]>;
                            default: () => never[];
                        };
                        options: {
                            type: PropType<any[]>;
                            default: () => never[];
                        };
                        optionLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        optionValue: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsSelectStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        label: {
                            type: typeof String;
                            default: string;
                        };
                        messages: {
                            type: PropType<Message<any>[]>;
                            default: () => Message<any>[];
                        };
                        name: {
                            type: typeof String;
                            default: string;
                        };
                        noDefaultRules: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        placeholder: {
                            type: typeof String;
                            default: string;
                        };
                        readonly: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        rules: {
                            type: PropType<Rule<any>[]>;
                            default: () => Rule<any>[];
                        };
                        state: {
                            type: PropType<UIState>;
                            default: UIState;
                        };
                        changed: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        valid: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        disabled: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        hidden: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        id: {
                            type: typeof String;
                            default: string;
                        };
                        noLabel: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        noMessages: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                        required: {
                            type: typeof Boolean;
                            default: boolean;
                        };
                    }>,
                    {
                        triggerRef: Readonly<ShallowRef<VsSelectTriggerRef | null>>;
                        searchInputRef: Readonly<ShallowRef<VsSearchInputRef | null>>;
                        optionsListRef: Readonly<ShallowRef<VsGroupedListRef | null>>;
                        triggerId: ComputedRef<string>;
                        optionsId: ComputedRef<string>;
                        isOpen: Ref<boolean, boolean>;
                        inputValue: Ref<any, any>;
                        colorSchemeClass: ComputedRef<string>;
                        sizeClass: ComputedRef<string>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentStyleSet: ComputedRef<Partial<VsSelectStyleSet>>;
                        classObj: ComputedRef<{
                            [x: string]: boolean;
                            'vs-disabled': boolean;
                            'vs-readonly': boolean;
                        }>;
                        computedId: ComputedRef<string>;
                        computedMessages: ComputedRef<StateMessage<UIState>[]>;
                        computedState: ComputedRef<UIState>;
                        computedDisabled: ComputedRef<boolean>;
                        computedReadonly: ComputedRef<boolean>;
                        filteredOptions: ComputedRef<OptionItem[]>;
                        shake: Ref<boolean, boolean>;
                        openOptions: () => void;
                        closeOptions: () => void;
                        isSelected: (optionId: string) => boolean;
                        toggleSelectAll: () => void;
                        isUsingSearch: ComputedRef<boolean>;
                        searchProps: ComputedRef<{
                            useRegex: boolean;
                            useCaseSensitive: boolean;
                            placeholder: string;
                        }>;
                        toggleOpen: () => void;
                        selectOptionItem: (optionItem: OptionItem) => void;
                        isSelectedAll: ComputedRef<boolean>;
                        computedColorScheme: ComputedRef<
                            | 'brown'
                            | 'red'
                            | 'orange'
                            | 'amber'
                            | 'yellow'
                            | 'lime'
                            | 'green'
                            | 'emerald'
                            | 'teal'
                            | 'cyan'
                            | 'sky'
                            | 'blue'
                            | 'indigo'
                            | 'violet'
                            | 'purple'
                            | 'fuchsia'
                            | 'pink'
                            | 'rose'
                            | 'gray'
                            | 'none'
                            | undefined
                        >;
                        onFocus: (e: FocusEvent) => void;
                        onBlur: (e: FocusEvent) => void;
                        focus: () => void;
                        blur: () => void;
                        validate: () => boolean;
                        clear: () => void;
                        reset: () => void;
                        isEmpty: ComputedRef<boolean>;
                        selectedOptions: ComputedRef<OptionItem[]>;
                        deselectOption: (optionId: string) => void;
                        getOptionStyleSet: (optionId: string) => CSSProperties;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    (
                        | 'blur'
                        | 'change'
                        | 'close'
                        | 'focus'
                        | 'open'
                        | 'clear'
                        | 'update:modelValue'
                        | 'update:changed'
                        | 'update:valid'
                        | 'click-option'
                    )[],
                    | 'blur'
                    | 'change'
                    | 'close'
                    | 'focus'
                    | 'open'
                    | 'clear'
                    | 'update:modelValue'
                    | 'update:changed'
                    | 'update:valid'
                    | 'click-option',
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            closableChips: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            collapseChips: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            multiple: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            noClear: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            optionsDisabled: {
                                type: PropType<boolean | ((option: any, index: number, options: any[]) => boolean)>;
                                default: boolean;
                            };
                            selectAll: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            modelValue: {
                                type: null;
                                default: null;
                            };
                            search: {
                                type: PropType<SearchProps>;
                                default: boolean;
                                validator: (value: SearchProps) => boolean;
                            };
                            min: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            max: {
                                type: PropType<number | string>;
                                default: string | number;
                                validator: (value: number | string) => boolean;
                            };
                            groupBy: {
                                type: PropType<(option: any, index: number) => string | null> | null;
                                default: null;
                            };
                            groupOrder: {
                                type: PropType<string[]>;
                                default: () => never[];
                            };
                            options: {
                                type: PropType<any[]>;
                                default: () => never[];
                            };
                            optionLabel: {
                                type: StringConstructor;
                                default: string;
                            };
                            optionValue: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsSelectStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            label: {
                                type: typeof String;
                                default: string;
                            };
                            messages: {
                                type: PropType<Message<any>[]>;
                                default: () => Message<any>[];
                            };
                            name: {
                                type: typeof String;
                                default: string;
                            };
                            noDefaultRules: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            placeholder: {
                                type: typeof String;
                                default: string;
                            };
                            readonly: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            rules: {
                                type: PropType<Rule<any>[]>;
                                default: () => Rule<any>[];
                            };
                            state: {
                                type: PropType<UIState>;
                                default: UIState;
                            };
                            changed: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            valid: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            disabled: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            hidden: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            id: {
                                type: typeof String;
                                default: string;
                            };
                            noLabel: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            noMessages: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                            required: {
                                type: typeof Boolean;
                                default: boolean;
                            };
                        }>
                    > &
                        Readonly<{
                            onFocus?: ((...args: any[]) => any) | undefined;
                            onBlur?: ((...args: any[]) => any) | undefined;
                            onChange?: ((...args: any[]) => any) | undefined;
                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                            onClear?: ((...args: any[]) => any) | undefined;
                            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                            onClose?: ((...args: any[]) => any) | undefined;
                            onOpen?: ((...args: any[]) => any) | undefined;
                            'onClick-option'?: ((...args: any[]) => any) | undefined;
                        }>,
                    {
                        label: string;
                        search: SearchProps;
                        messages: Message<any>[];
                        name: string;
                        noDefaultRules: boolean;
                        placeholder: string;
                        readonly: boolean;
                        rules: Rule<any>[];
                        state: UIState;
                        changed: boolean;
                        valid: boolean;
                        disabled: boolean;
                        hidden: boolean;
                        id: string;
                        noLabel: boolean;
                        noMessages: boolean;
                        required: boolean;
                        min: string | number;
                        max: string | number;
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        multiple: boolean;
                        modelValue: any;
                        options: any[];
                        optionLabel: string;
                        optionValue: string;
                        noClear: boolean;
                        groupBy: (option: any, index: number) => string | null;
                        groupOrder: string[];
                        collapseChips: boolean;
                        closableChips: boolean;
                        optionsDisabled: boolean | ((option: any, index: number, options: any[]) => boolean);
                        selectAll: boolean;
                    },
                    {},
                    {
                        VsFloating: DefineComponent<
                            ExtractPropTypes<{
                                followWidth: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                overlayId: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                modelValue: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                target: {
                                    type: StringConstructor;
                                    required: boolean;
                                    default: string;
                                };
                                align: {
                                    type: PropType<Alignment>;
                                    default: 'start' | 'center' | 'end';
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                enterDelay: {
                                    type: (StringConstructor | NumberConstructor)[];
                                    default: number;
                                };
                                leaveDelay: {
                                    type: (StringConstructor | NumberConstructor)[];
                                    default: number;
                                };
                                margin: {
                                    type: (StringConstructor | NumberConstructor)[];
                                    default: number;
                                };
                                noAnimation: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                placement: {
                                    type: PropType<Placement>;
                                    default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                                };
                            }>,
                            {
                                floatingRef: Readonly<ShallowRef<HTMLElement | null>>;
                                computedPlacement: Ref<
                                    'top' | 'right' | 'bottom' | 'left' | 'middle' | null,
                                    'top' | 'right' | 'bottom' | 'left' | 'middle' | null
                                >;
                                isVisible: Ref<boolean, boolean>;
                                isFloated: Ref<boolean, boolean>;
                                animationClass: ComputedRef<string | null>;
                                floatingStyle: ComputedRef<
                                    | {
                                          animationDelay?: undefined;
                                      }
                                    | {
                                          animationDelay: string;
                                      }
                                >;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            'update:modelValue'[],
                            'update:modelValue',
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    followWidth: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    overlayId: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    modelValue: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    target: {
                                        type: StringConstructor;
                                        required: boolean;
                                        default: string;
                                    };
                                    align: {
                                        type: PropType<Alignment>;
                                        default: 'start' | 'center' | 'end';
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    enterDelay: {
                                        type: (StringConstructor | NumberConstructor)[];
                                        default: number;
                                    };
                                    leaveDelay: {
                                        type: (StringConstructor | NumberConstructor)[];
                                        default: number;
                                    };
                                    margin: {
                                        type: (StringConstructor | NumberConstructor)[];
                                        default: number;
                                    };
                                    noAnimation: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    placement: {
                                        type: PropType<Placement>;
                                        default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                                    };
                                }>
                            > &
                                Readonly<{
                                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                }>,
                            {
                                disabled: boolean;
                                margin: string | number;
                                modelValue: boolean;
                                target: string;
                                placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                                overlayId: string;
                                followWidth: boolean;
                                align: 'start' | 'center' | 'end';
                                enterDelay: string | number;
                                leaveDelay: string | number;
                                noAnimation: boolean;
                            },
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsInputWrapper: DefineComponent<
                            ExtractPropTypes<{
                                groupLabel: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                messages: {
                                    type: PropType<StateMessage<UIState>[]>;
                                    default: () => never[];
                                };
                                shake: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsInputWrapperStyleSet>;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                            }>,
                            {
                                needToShake: Ref<boolean, boolean>;
                                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    groupLabel: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    messages: {
                                        type: PropType<StateMessage<UIState>[]>;
                                        default: () => never[];
                                    };
                                    shake: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsInputWrapperStyleSet>;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {
                                label: string;
                                messages: StateMessage<UIState>[];
                                disabled: boolean;
                                hidden: boolean;
                                id: string;
                                noLabel: boolean;
                                noMessages: boolean;
                                required: boolean;
                                groupLabel: boolean;
                                shake: boolean;
                            },
                            {},
                            {
                                VsResponsive: DefineComponent<
                                    ExtractPropTypes<{
                                        tag: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>,
                                    {
                                        responsiveClasses: ComputedRef<string[]>;
                                        responsiveStyles: ComputedRef<Record<string, string>>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            tag: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        tag: string;
                                    },
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                                VsMessage: DefineComponent<
                                    ExtractPropTypes<{
                                        state: {
                                            type: PropType<UIState>;
                                            default: string;
                                        };
                                        text: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsMessageStyleSet>;
                                        };
                                    }>,
                                    {
                                        colorClass: ComputedRef<
                                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                                        >;
                                        icon: ComputedRef<Component>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            state: {
                                                type: PropType<UIState>;
                                                default: string;
                                            };
                                            text: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsMessageStyleSet>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        text: string;
                                        state: UIState;
                                    },
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsSearchInput: DefineComponent<
                            ExtractPropTypes<{
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                placeholder: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                readonly: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                useCaseSensitive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                useRegex: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                modelValue: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                caseSensitive: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                regex: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                styleSet: {
                                    type: PropType<string | VsSearchInputStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                inputRef: Readonly<ShallowRef<VsInputRef | null>>;
                                searchText: Ref<string, string>;
                                isCaseSensitiveOn: Ref<boolean, boolean>;
                                isRegexOn: Ref<boolean, boolean>;
                                computedColorScheme: ComputedRef<
                                    | 'brown'
                                    | 'red'
                                    | 'orange'
                                    | 'amber'
                                    | 'yellow'
                                    | 'lime'
                                    | 'green'
                                    | 'emerald'
                                    | 'teal'
                                    | 'cyan'
                                    | 'sky'
                                    | 'blue'
                                    | 'indigo'
                                    | 'violet'
                                    | 'purple'
                                    | 'fuchsia'
                                    | 'pink'
                                    | 'rose'
                                    | 'gray'
                                    | 'none'
                                    | undefined
                                >;
                                componentStyleSet: ComputedRef<Partial<VsSearchInputStyleSet>>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                onInputChange: (value: string | number | null) => void;
                                match: (text: string) => boolean;
                                focus: () => void;
                                blur: () => void;
                                select: () => void;
                                clear: () => void;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            ('search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex')[],
                            'search' | 'update:modelValue' | 'update:caseSensitive' | 'update:regex',
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    placeholder: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    readonly: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    useCaseSensitive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    useRegex: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    modelValue: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    caseSensitive: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    regex: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsSearchInputStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{
                                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                    onSearch?: ((...args: any[]) => any) | undefined;
                                    'onUpdate:caseSensitive'?: ((...args: any[]) => any) | undefined;
                                    'onUpdate:regex'?: ((...args: any[]) => any) | undefined;
                                }>,
                            {
                                placeholder: string;
                                readonly: boolean;
                                disabled: boolean;
                                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                modelValue: string;
                                useCaseSensitive: boolean;
                                useRegex: boolean;
                                caseSensitive: boolean;
                                regex: boolean;
                            },
                            {},
                            {
                                VsInput: DefineComponent<
                                    ExtractPropTypes<{
                                        autocomplete: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        noClear: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        type: {
                                            type: PropType<VsInputType>;
                                            default: string;
                                        };
                                        modelValue: {
                                            type: PropType<VsInputValueType>;
                                            default: null;
                                        };
                                        modelModifiers: {
                                            type: PropType<StringModifiers>;
                                            default: () => {};
                                        };
                                        min: {
                                            type: PropType<number | string>;
                                            default: string | number;
                                            validator: (value: number | string) => boolean;
                                        };
                                        max: {
                                            type: PropType<number | string>;
                                            default: string | number;
                                            validator: (value: number | string) => boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsInputStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        label: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        messages: {
                                            type: PropType<Message<VsInputValueType>[]>;
                                            default: () => Message<VsInputValueType>[];
                                        };
                                        name: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noDefaultRules: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        placeholder: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        readonly: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        rules: {
                                            type: PropType<Rule<VsInputValueType>[]>;
                                            default: () => Rule<VsInputValueType>[];
                                        };
                                        state: {
                                            type: PropType<UIState>;
                                            default: UIState;
                                        };
                                        changed: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        valid: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        hidden: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        id: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noLabel: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        noMessages: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        required: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                    }>,
                                    {
                                        inputRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                                        classObj: ComputedRef<{
                                            [x: string]: boolean;
                                            'vs-focus-visible': boolean;
                                            'vs-focus-within': boolean;
                                            'vs-disabled': boolean;
                                            'vs-readonly': boolean;
                                        }>;
                                        colorSchemeClass: ComputedRef<string>;
                                        componentStyleSet: ComputedRef<Partial<VsInputStyleSet>>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                        inputValue: Ref<VsInputValueType, VsInputValueType>;
                                        computedMessages: ComputedRef<StateMessage<UIState>[]>;
                                        computedDisabled: ComputedRef<boolean>;
                                        computedReadonly: ComputedRef<boolean>;
                                        renderClearButton: ComputedRef<boolean>;
                                        shake: Ref<boolean, boolean>;
                                        stateBoxClasses: ComputedRef<{}>;
                                        computedId: ComputedRef<string>;
                                        onInput: (event: Event) => void;
                                        focus: () => void;
                                        blur: () => void;
                                        select: () => void;
                                        clear: () => void;
                                        reset: () => void;
                                        onFocus: (e: FocusEvent) => void;
                                        onBlur: (e: FocusEvent) => void;
                                        validate: () => boolean;
                                        clearWithFocus: () => void;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    (
                                        | 'blur'
                                        | 'change'
                                        | 'focus'
                                        | 'clear'
                                        | 'update:modelValue'
                                        | 'update:changed'
                                        | 'update:valid'
                                    )[],
                                    | 'blur'
                                    | 'change'
                                    | 'focus'
                                    | 'clear'
                                    | 'update:modelValue'
                                    | 'update:changed'
                                    | 'update:valid',
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            autocomplete: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            noClear: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            type: {
                                                type: PropType<VsInputType>;
                                                default: string;
                                            };
                                            modelValue: {
                                                type: PropType<VsInputValueType>;
                                                default: null;
                                            };
                                            modelModifiers: {
                                                type: PropType<StringModifiers>;
                                                default: () => {};
                                            };
                                            min: {
                                                type: PropType<number | string>;
                                                default: string | number;
                                                validator: (value: number | string) => boolean;
                                            };
                                            max: {
                                                type: PropType<number | string>;
                                                default: string | number;
                                                validator: (value: number | string) => boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsInputStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            label: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            messages: {
                                                type: PropType<Message<VsInputValueType>[]>;
                                                default: () => Message<VsInputValueType>[];
                                            };
                                            name: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noDefaultRules: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            placeholder: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            readonly: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            rules: {
                                                type: PropType<Rule<VsInputValueType>[]>;
                                                default: () => Rule<VsInputValueType>[];
                                            };
                                            state: {
                                                type: PropType<UIState>;
                                                default: UIState;
                                            };
                                            changed: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            valid: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            disabled: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            hidden: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            id: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noLabel: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            noMessages: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            required: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                        }>
                                    > &
                                        Readonly<{
                                            onFocus?: ((...args: any[]) => any) | undefined;
                                            onBlur?: ((...args: any[]) => any) | undefined;
                                            onChange?: ((...args: any[]) => any) | undefined;
                                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                            onClear?: ((...args: any[]) => any) | undefined;
                                            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                                        }>,
                                    {
                                        label: string;
                                        messages: Message<VsInputValueType>[];
                                        name: string;
                                        noDefaultRules: boolean;
                                        placeholder: string;
                                        readonly: boolean;
                                        rules: Rule<VsInputValueType>[];
                                        state: UIState;
                                        changed: boolean;
                                        valid: boolean;
                                        disabled: boolean;
                                        hidden: boolean;
                                        id: string;
                                        noLabel: boolean;
                                        noMessages: boolean;
                                        required: boolean;
                                        min: string | number;
                                        max: string | number;
                                        type: VsInputType;
                                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                        modelValue: VsInputValueType;
                                        autocomplete: boolean;
                                        noClear: boolean;
                                        modelModifiers: StringModifiers;
                                    },
                                    {},
                                    {
                                        VsInputWrapper: DefineComponent<
                                            ExtractPropTypes<{
                                                groupLabel: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                messages: {
                                                    type: PropType<StateMessage<UIState>[]>;
                                                    default: () => never[];
                                                };
                                                shake: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsInputWrapperStyleSet>;
                                                };
                                                disabled: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                hidden: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                id: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                label: {
                                                    type: typeof String;
                                                    default: string;
                                                };
                                                noLabel: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                noMessages: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                required: {
                                                    type: typeof Boolean;
                                                    default: boolean;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                            }>,
                                            {
                                                needToShake: Ref<boolean, boolean>;
                                                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                                componentInlineStyle: ComputedRef<CSSProperties>;
                                            },
                                            {},
                                            {},
                                            {},
                                            ComponentOptionsMixin,
                                            ComponentOptionsMixin,
                                            {},
                                            string,
                                            PublicProps,
                                            Readonly<
                                                ExtractPropTypes<{
                                                    groupLabel: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    messages: {
                                                        type: PropType<StateMessage<UIState>[]>;
                                                        default: () => never[];
                                                    };
                                                    shake: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsInputWrapperStyleSet>;
                                                    };
                                                    disabled: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    hidden: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    id: {
                                                        type: typeof String;
                                                        default: string;
                                                    };
                                                    label: {
                                                        type: typeof String;
                                                        default: string;
                                                    };
                                                    noLabel: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    noMessages: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    required: {
                                                        type: typeof Boolean;
                                                        default: boolean;
                                                    };
                                                    width: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                    grid: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                }>
                                            > &
                                                Readonly<{}>,
                                            {
                                                label: string;
                                                messages: StateMessage<UIState>[];
                                                disabled: boolean;
                                                hidden: boolean;
                                                id: string;
                                                noLabel: boolean;
                                                noMessages: boolean;
                                                required: boolean;
                                                groupLabel: boolean;
                                                shake: boolean;
                                            },
                                            {},
                                            {
                                                VsResponsive: DefineComponent<
                                                    ExtractPropTypes<{
                                                        tag: {
                                                            type: StringConstructor;
                                                            default: string;
                                                        };
                                                        width: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                        grid: {
                                                            type: PropType<string | number | Breakpoints>;
                                                        };
                                                    }>,
                                                    {
                                                        responsiveClasses: ComputedRef<string[]>;
                                                        responsiveStyles: ComputedRef<Record<string, string>>;
                                                    },
                                                    {},
                                                    {},
                                                    {},
                                                    ComponentOptionsMixin,
                                                    ComponentOptionsMixin,
                                                    {},
                                                    string,
                                                    PublicProps,
                                                    Readonly<
                                                        ExtractPropTypes<{
                                                            tag: {
                                                                type: StringConstructor;
                                                                default: string;
                                                            };
                                                            width: {
                                                                type: PropType<string | number | Breakpoints>;
                                                            };
                                                            grid: {
                                                                type: PropType<string | number | Breakpoints>;
                                                            };
                                                        }>
                                                    > &
                                                        Readonly<{}>,
                                                    {
                                                        tag: string;
                                                    },
                                                    {},
                                                    {},
                                                    {},
                                                    string,
                                                    ComponentProvideOptions,
                                                    true,
                                                    {},
                                                    any
                                                >;
                                                VsMessage: DefineComponent<
                                                    ExtractPropTypes<{
                                                        state: {
                                                            type: PropType<UIState>;
                                                            default: string;
                                                        };
                                                        text: {
                                                            type: StringConstructor;
                                                            default: string;
                                                        };
                                                        styleSet: {
                                                            type: PropType<string | VsMessageStyleSet>;
                                                        };
                                                    }>,
                                                    {
                                                        colorClass: ComputedRef<
                                                            | 'vs-cs-blue'
                                                            | 'vs-cs-green'
                                                            | 'vs-cs-amber'
                                                            | 'vs-cs-red'
                                                            | 'vs-cs-default'
                                                        >;
                                                        icon: ComputedRef<Component>;
                                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                                    },
                                                    {},
                                                    {},
                                                    {},
                                                    ComponentOptionsMixin,
                                                    ComponentOptionsMixin,
                                                    {},
                                                    string,
                                                    PublicProps,
                                                    Readonly<
                                                        ExtractPropTypes<{
                                                            state: {
                                                                type: PropType<UIState>;
                                                                default: string;
                                                            };
                                                            text: {
                                                                type: StringConstructor;
                                                                default: string;
                                                            };
                                                            styleSet: {
                                                                type: PropType<string | VsMessageStyleSet>;
                                                            };
                                                        }>
                                                    > &
                                                        Readonly<{}>,
                                                    {
                                                        text: string;
                                                        state: UIState;
                                                    },
                                                    {},
                                                    {},
                                                    {},
                                                    string,
                                                    ComponentProvideOptions,
                                                    true,
                                                    {},
                                                    any
                                                >;
                                            },
                                            {},
                                            string,
                                            ComponentProvideOptions,
                                            true,
                                            {},
                                            any
                                        >;
                                        XIcon: LucideIcon;
                                    },
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                                VsToggle: DefineComponent<
                                    ExtractPropTypes<{
                                        modelValue: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        circle: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        ghost: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        loading: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        outline: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        primary: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        responsive: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        type: {
                                            type: PropType<'button' | 'submit' | 'reset'>;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsToggleStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>,
                                    {
                                        colorSchemeClass: ComputedRef<string>;
                                        componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        toggle: () => void;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    ('toggle' | 'update:modelValue')[],
                                    'toggle' | 'update:modelValue',
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            modelValue: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            circle: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            disabled: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            ghost: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            loading: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            outline: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            primary: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            responsive: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            type: {
                                                type: PropType<'button' | 'submit' | 'reset'>;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsToggleStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>
                                    > &
                                        Readonly<{
                                            onToggle?: ((...args: any[]) => any) | undefined;
                                            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                        }>,
                                    {
                                        circle: boolean;
                                        disabled: boolean;
                                        type: 'button' | 'reset' | 'submit';
                                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                        outline: boolean;
                                        primary: boolean;
                                        modelValue: boolean;
                                        ghost: boolean;
                                        loading: boolean;
                                        responsive: boolean;
                                    },
                                    {},
                                    {
                                        VsButton: DefineComponent<
                                            ExtractPropTypes<{
                                                circle: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                disabled: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                ghost: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                loading: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                outline: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                primary: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                responsive: {
                                                    type: BooleanConstructor;
                                                    default: boolean;
                                                };
                                                size: {
                                                    type: PropType<Size>;
                                                    default: string;
                                                };
                                                type: {
                                                    type: PropType<'button' | 'submit' | 'reset'>;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsButtonStyleSet>;
                                                };
                                                colorScheme: {
                                                    type: PropType<ColorScheme>;
                                                };
                                            }>,
                                            {
                                                colorSchemeClass: ComputedRef<string>;
                                                styleSetVariables: ComputedRef<Record<string, string>>;
                                                componentInlineStyle: ComputedRef<CSSProperties>;
                                                classObj: ComputedRef<{
                                                    [x: string]: boolean;
                                                    'vs-focus-visible': boolean;
                                                    'vs-circle': boolean;
                                                    'vs-disabled': boolean;
                                                    'vs-ghost': boolean;
                                                    'vs-loading-state': boolean;
                                                    'vs-outline': boolean;
                                                    'vs-primary': boolean;
                                                    'vs-responsive': boolean;
                                                }>;
                                                buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                                                componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                                            },
                                            {},
                                            {},
                                            {},
                                            ComponentOptionsMixin,
                                            ComponentOptionsMixin,
                                            {},
                                            string,
                                            PublicProps,
                                            Readonly<
                                                ExtractPropTypes<{
                                                    circle: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    disabled: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    ghost: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    loading: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    outline: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    primary: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    responsive: {
                                                        type: BooleanConstructor;
                                                        default: boolean;
                                                    };
                                                    size: {
                                                        type: PropType<Size>;
                                                        default: string;
                                                    };
                                                    type: {
                                                        type: PropType<'button' | 'submit' | 'reset'>;
                                                        default: string;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsButtonStyleSet>;
                                                    };
                                                    colorScheme: {
                                                        type: PropType<ColorScheme>;
                                                    };
                                                }>
                                            > &
                                                Readonly<{}>,
                                            {
                                                circle: boolean;
                                                disabled: boolean;
                                                type: 'button' | 'reset' | 'submit';
                                                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                                outline: boolean;
                                                primary: boolean;
                                                ghost: boolean;
                                                loading: boolean;
                                                responsive: boolean;
                                            },
                                            {},
                                            {
                                                VsLoading: DefineComponent<
                                                    ExtractPropTypes<{
                                                        width: {
                                                            type: (StringConstructor | NumberConstructor)[];
                                                        };
                                                        height: {
                                                            type: (StringConstructor | NumberConstructor)[];
                                                        };
                                                        styleSet: {
                                                            type: PropType<string | VsLoadingStyleSet>;
                                                        };
                                                        colorScheme: {
                                                            type: PropType<ColorScheme>;
                                                        };
                                                    }>,
                                                    {
                                                        colorSchemeClass: ComputedRef<string>;
                                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                                    },
                                                    {},
                                                    {},
                                                    {},
                                                    ComponentOptionsMixin,
                                                    ComponentOptionsMixin,
                                                    {},
                                                    string,
                                                    PublicProps,
                                                    Readonly<
                                                        ExtractPropTypes<{
                                                            width: {
                                                                type: (StringConstructor | NumberConstructor)[];
                                                            };
                                                            height: {
                                                                type: (StringConstructor | NumberConstructor)[];
                                                            };
                                                            styleSet: {
                                                                type: PropType<string | VsLoadingStyleSet>;
                                                            };
                                                            colorScheme: {
                                                                type: PropType<ColorScheme>;
                                                            };
                                                        }>
                                                    > &
                                                        Readonly<{}>,
                                                    {},
                                                    {},
                                                    {},
                                                    {},
                                                    string,
                                                    ComponentProvideOptions,
                                                    true,
                                                    {},
                                                    any
                                                >;
                                            },
                                            {},
                                            string,
                                            ComponentProvideOptions,
                                            true,
                                            {},
                                            any
                                        >;
                                    },
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsCheckbox: DefineComponent<
                            ExtractPropTypes<{
                                beforeChange: {
                                    type: PropType<(from: any, to: any, optionValue: any) => Promise<boolean> | null>;
                                    default: null;
                                };
                                checked: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                checkLabel: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                indeterminate: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                multiple: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                size: {
                                    type: PropType<Size>;
                                    default: string;
                                };
                                trueValue: {
                                    type: null;
                                    default: boolean;
                                };
                                falseValue: {
                                    type: null;
                                    default: boolean;
                                };
                                modelValue: {
                                    type: null;
                                    default: boolean;
                                };
                                width: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                grid: {
                                    type: PropType<string | number | Breakpoints>;
                                };
                                label: {
                                    type: typeof String;
                                    default: string;
                                };
                                messages: {
                                    type: PropType<Message<any>[]>;
                                    default: () => Message<any>[];
                                };
                                name: {
                                    type: typeof String;
                                    default: string;
                                };
                                noDefaultRules: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                readonly: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                rules: {
                                    type: PropType<Rule<any>[]>;
                                    default: () => Rule<any>[];
                                };
                                state: {
                                    type: PropType<UIState>;
                                    default: UIState;
                                };
                                changed: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                valid: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                disabled: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                hidden: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                id: {
                                    type: typeof String;
                                    default: string;
                                };
                                noLabel: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                noMessages: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                required: {
                                    type: typeof Boolean;
                                    default: boolean;
                                };
                                styleSet: {
                                    type: PropType<string | VsCheckboxStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                checkboxRef: Readonly<ShallowRef<HTMLInputElement | null>>;
                                colorSchemeClass: ComputedRef<string>;
                                componentStyleSet: ComputedRef<Partial<VsCheckboxStyleSet>>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                                classObj: ComputedRef<{
                                    'vs-checked': boolean;
                                    'vs-disabled': boolean;
                                    'vs-focus-visible': boolean;
                                    'vs-indeterminate': boolean;
                                    'vs-readonly': boolean;
                                }>;
                                sizeClass: ComputedRef<string>;
                                stateBoxClasses: ComputedRef<{}>;
                                computedId: ComputedRef<string>;
                                computedDisabled: ComputedRef<boolean>;
                                computedReadonly: ComputedRef<boolean>;
                                computedMessages: ComputedRef<StateMessage<UIState>[]>;
                                computedState: ComputedRef<UIState>;
                                convertToString: (value: any) => string;
                                inputValue: Ref<any, any>;
                                isChecked: ComputedRef<boolean>;
                                shake: Ref<boolean, boolean>;
                                toggle: (e: MouseEvent) => Promise<void>;
                                onFocus: (e: FocusEvent) => void;
                                onBlur: (e: FocusEvent) => void;
                                validate: () => boolean;
                                clear: () => void;
                                reset: () => void;
                                focus: () => void;
                                blur: () => void;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            (
                                | 'blur'
                                | 'change'
                                | 'focus'
                                | 'toggle'
                                | 'clear'
                                | 'update:modelValue'
                                | 'update:changed'
                                | 'update:valid'
                            )[],
                            | 'blur'
                            | 'change'
                            | 'focus'
                            | 'toggle'
                            | 'clear'
                            | 'update:modelValue'
                            | 'update:changed'
                            | 'update:valid',
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    beforeChange: {
                                        type: PropType<
                                            (from: any, to: any, optionValue: any) => Promise<boolean> | null
                                        >;
                                        default: null;
                                    };
                                    checked: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    checkLabel: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    indeterminate: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    multiple: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    size: {
                                        type: PropType<Size>;
                                        default: string;
                                    };
                                    trueValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    falseValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    modelValue: {
                                        type: null;
                                        default: boolean;
                                    };
                                    width: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    grid: {
                                        type: PropType<string | number | Breakpoints>;
                                    };
                                    label: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    messages: {
                                        type: PropType<Message<any>[]>;
                                        default: () => Message<any>[];
                                    };
                                    name: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noDefaultRules: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    readonly: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    rules: {
                                        type: PropType<Rule<any>[]>;
                                        default: () => Rule<any>[];
                                    };
                                    state: {
                                        type: PropType<UIState>;
                                        default: UIState;
                                    };
                                    changed: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    valid: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    hidden: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    id: {
                                        type: typeof String;
                                        default: string;
                                    };
                                    noLabel: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    noMessages: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    required: {
                                        type: typeof Boolean;
                                        default: boolean;
                                    };
                                    styleSet: {
                                        type: PropType<string | VsCheckboxStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{
                                    onFocus?: ((...args: any[]) => any) | undefined;
                                    onBlur?: ((...args: any[]) => any) | undefined;
                                    onChange?: ((...args: any[]) => any) | undefined;
                                    onToggle?: ((...args: any[]) => any) | undefined;
                                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                                    onClear?: ((...args: any[]) => any) | undefined;
                                    'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
                                    'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
                                }>,
                            {
                                label: string;
                                messages: Message<any>[];
                                name: string;
                                noDefaultRules: boolean;
                                readonly: boolean;
                                rules: Rule<any>[];
                                state: UIState;
                                changed: boolean;
                                valid: boolean;
                                disabled: boolean;
                                hidden: boolean;
                                id: string;
                                noLabel: boolean;
                                noMessages: boolean;
                                required: boolean;
                                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                multiple: boolean;
                                modelValue: any;
                                beforeChange: (from: any, to: any, optionValue: any) => Promise<boolean> | null;
                                checked: boolean;
                                checkLabel: string;
                                indeterminate: boolean;
                                trueValue: any;
                                falseValue: any;
                            },
                            {},
                            {
                                VsInputWrapper: DefineComponent<
                                    ExtractPropTypes<{
                                        groupLabel: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        messages: {
                                            type: PropType<StateMessage<UIState>[]>;
                                            default: () => never[];
                                        };
                                        shake: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsInputWrapperStyleSet>;
                                        };
                                        disabled: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        hidden: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        id: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        label: {
                                            type: typeof String;
                                            default: string;
                                        };
                                        noLabel: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        noMessages: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        required: {
                                            type: typeof Boolean;
                                            default: boolean;
                                        };
                                        width: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                        grid: {
                                            type: PropType<string | number | Breakpoints>;
                                        };
                                    }>,
                                    {
                                        needToShake: Ref<boolean, boolean>;
                                        componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            groupLabel: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            messages: {
                                                type: PropType<StateMessage<UIState>[]>;
                                                default: () => never[];
                                            };
                                            shake: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsInputWrapperStyleSet>;
                                            };
                                            disabled: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            hidden: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            id: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            label: {
                                                type: typeof String;
                                                default: string;
                                            };
                                            noLabel: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            noMessages: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            required: {
                                                type: typeof Boolean;
                                                default: boolean;
                                            };
                                            width: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                            grid: {
                                                type: PropType<string | number | Breakpoints>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        label: string;
                                        messages: StateMessage<UIState>[];
                                        disabled: boolean;
                                        hidden: boolean;
                                        id: string;
                                        noLabel: boolean;
                                        noMessages: boolean;
                                        required: boolean;
                                        groupLabel: boolean;
                                        shake: boolean;
                                    },
                                    {},
                                    {
                                        VsResponsive: DefineComponent<
                                            ExtractPropTypes<{
                                                tag: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                width: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                                grid: {
                                                    type: PropType<string | number | Breakpoints>;
                                                };
                                            }>,
                                            {
                                                responsiveClasses: ComputedRef<string[]>;
                                                responsiveStyles: ComputedRef<Record<string, string>>;
                                            },
                                            {},
                                            {},
                                            {},
                                            ComponentOptionsMixin,
                                            ComponentOptionsMixin,
                                            {},
                                            string,
                                            PublicProps,
                                            Readonly<
                                                ExtractPropTypes<{
                                                    tag: {
                                                        type: StringConstructor;
                                                        default: string;
                                                    };
                                                    width: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                    grid: {
                                                        type: PropType<string | number | Breakpoints>;
                                                    };
                                                }>
                                            > &
                                                Readonly<{}>,
                                            {
                                                tag: string;
                                            },
                                            {},
                                            {},
                                            {},
                                            string,
                                            ComponentProvideOptions,
                                            true,
                                            {},
                                            any
                                        >;
                                        VsMessage: DefineComponent<
                                            ExtractPropTypes<{
                                                state: {
                                                    type: PropType<UIState>;
                                                    default: string;
                                                };
                                                text: {
                                                    type: StringConstructor;
                                                    default: string;
                                                };
                                                styleSet: {
                                                    type: PropType<string | VsMessageStyleSet>;
                                                };
                                            }>,
                                            {
                                                colorClass: ComputedRef<
                                                    | 'vs-cs-blue'
                                                    | 'vs-cs-green'
                                                    | 'vs-cs-amber'
                                                    | 'vs-cs-red'
                                                    | 'vs-cs-default'
                                                >;
                                                icon: ComputedRef<Component>;
                                                styleSetVariables: ComputedRef<Record<string, string>>;
                                                componentInlineStyle: ComputedRef<CSSProperties>;
                                            },
                                            {},
                                            {},
                                            {},
                                            ComponentOptionsMixin,
                                            ComponentOptionsMixin,
                                            {},
                                            string,
                                            PublicProps,
                                            Readonly<
                                                ExtractPropTypes<{
                                                    state: {
                                                        type: PropType<UIState>;
                                                        default: string;
                                                    };
                                                    text: {
                                                        type: StringConstructor;
                                                        default: string;
                                                    };
                                                    styleSet: {
                                                        type: PropType<string | VsMessageStyleSet>;
                                                    };
                                                }>
                                            > &
                                                Readonly<{}>,
                                            {
                                                text: string;
                                                state: UIState;
                                            },
                                            {},
                                            {},
                                            {},
                                            string,
                                            ComponentProvideOptions,
                                            true,
                                            {},
                                            any
                                        >;
                                    },
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsGroupedList: DefineComponent<
                            ExtractPropTypes<{
                                items: {
                                    type: PropType<OptionItem[]>;
                                    default: () => never[];
                                };
                                groupBy: {
                                    type: PropType<(option: any, index: number) => string | null> | null;
                                    default: null;
                                };
                                groupOrder: {
                                    type: PropType<string[]>;
                                    default: () => never[];
                                };
                                styleSet: {
                                    type: PropType<string | VsGroupedListStyleSet>;
                                };
                            }>,
                            {
                                visibleRenderRef: Readonly<ShallowRef<VsVisibleRenderRef | null>>;
                                innerScrollRef: Readonly<ShallowRef<VsInnerScrollRef | null>>;
                                componentStyleSet: ComputedRef<Partial<VsGroupedListStyleSet>>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                                groupedItems: ComputedRef<VsGroupedListGroup[]>;
                                emitClickItem: (
                                    item: OptionItem,
                                    groupedIndex: number,
                                    group: VsGroupedListGroup,
                                    groupIndex: number,
                                ) => void;
                                scrollToItem: (id: string) => void;
                                hasScroll: () => boolean;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            'click-item'[],
                            'click-item',
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    items: {
                                        type: PropType<OptionItem[]>;
                                        default: () => never[];
                                    };
                                    groupBy: {
                                        type: PropType<(option: any, index: number) => string | null> | null;
                                        default: null;
                                    };
                                    groupOrder: {
                                        type: PropType<string[]>;
                                        default: () => never[];
                                    };
                                    styleSet: {
                                        type: PropType<string | VsGroupedListStyleSet>;
                                    };
                                }>
                            > &
                                Readonly<{
                                    'onClick-item'?: ((...args: any[]) => any) | undefined;
                                }>,
                            {
                                items: OptionItem[];
                                groupBy: (option: any, index: number) => string | null;
                                groupOrder: string[];
                            },
                            {},
                            {
                                VsInnerScroll: DefineComponent<
                                    ExtractPropTypes<{
                                        hideScroll: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsInnerScrollStyleSet>;
                                        };
                                    }>,
                                    {
                                        componentStyleSet: ComputedRef<Partial<VsInnerScrollStyleSet>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                        hasScroll: () => boolean;
                                        bodyRef: Readonly<ShallowRef<HTMLElement | null>>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            hideScroll: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsInnerScrollStyleSet>;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        hideScroll: boolean;
                                    },
                                    {},
                                    {},
                                    {
                                        scrollShadow: Directive<HTMLElement, boolean | undefined>;
                                    },
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                                VsVisibleRender: DefineComponent<
                                    ExtractPropTypes<{
                                        selector: {
                                            type: StringConstructor;
                                            default: null;
                                        };
                                        disabled: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        height: {
                                            type: (StringConstructor | NumberConstructor)[];
                                        };
                                        rootMargin: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        tag: {
                                            type: StringConstructor;
                                            default: string;
                                        };
                                        threshold: {
                                            type: NumberConstructor;
                                            default: number;
                                            validator: (value: number) => boolean;
                                        };
                                    }>,
                                    {
                                        containerStyle: ComputedRef<
                                            | {
                                                  height?: undefined;
                                                  overflowY?: undefined;
                                              }
                                            | {
                                                  height: string;
                                                  overflowY: string;
                                              }
                                        >;
                                        scrollToElement: (element: HTMLElement) => void;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    {},
                                    string,
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            selector: {
                                                type: StringConstructor;
                                                default: null;
                                            };
                                            disabled: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            height: {
                                                type: (StringConstructor | NumberConstructor)[];
                                            };
                                            rootMargin: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            tag: {
                                                type: StringConstructor;
                                                default: string;
                                            };
                                            threshold: {
                                                type: NumberConstructor;
                                                default: number;
                                                validator: (value: number) => boolean;
                                            };
                                        }>
                                    > &
                                        Readonly<{}>,
                                    {
                                        disabled: boolean;
                                        tag: string;
                                        selector: string;
                                        rootMargin: string;
                                        threshold: number;
                                    },
                                    {},
                                    {},
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                        VsSelectTrigger: DefineComponent<
                            ExtractPropTypes<{
                                styleSet: {
                                    type: PropType<VsSelectStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                                collapseChips: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                closableChips: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                isEmpty: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                isOpen: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                multiple: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                noClear: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                placeholder: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                readonly: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                selectedOptions: {
                                    type: PropType<OptionItem[]>;
                                    default: () => never[];
                                };
                                state: {
                                    type: PropType<UIState>;
                                    default: string;
                                };
                            }>,
                            {
                                triggerRef: Readonly<ShallowRef<HTMLElement | null>>;
                                stateBoxClasses: ComputedRef<{}>;
                                renderClearButton: ComputedRef<boolean>;
                                displayLabel: ComputedRef<string>;
                                triggerClassObj: ComputedRef<{
                                    'vs-focusable': boolean;
                                    'vs-focus-within': boolean;
                                }>;
                                componentStyleSet: ComputedRef<Partial<VsSelectStyleSet>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                                focus: () => void;
                                blur: () => void;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            ('click' | 'blur' | 'focus' | 'clear' | 'deselect')[],
                            'click' | 'blur' | 'focus' | 'clear' | 'deselect',
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    styleSet: {
                                        type: PropType<VsSelectStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                    collapseChips: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    closableChips: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    disabled: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    isEmpty: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    isOpen: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    multiple: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    noClear: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    placeholder: {
                                        type: StringConstructor;
                                        default: string;
                                    };
                                    readonly: {
                                        type: BooleanConstructor;
                                        default: boolean;
                                    };
                                    selectedOptions: {
                                        type: PropType<OptionItem[]>;
                                        default: () => never[];
                                    };
                                    state: {
                                        type: PropType<UIState>;
                                        default: string;
                                    };
                                }>
                            > &
                                Readonly<{
                                    onFocus?: ((...args: any[]) => any) | undefined;
                                    onBlur?: ((...args: any[]) => any) | undefined;
                                    onClick?: ((...args: any[]) => any) | undefined;
                                    onClear?: ((...args: any[]) => any) | undefined;
                                    onDeselect?: ((...args: any[]) => any) | undefined;
                                }>,
                            {
                                placeholder: string;
                                readonly: boolean;
                                state: UIState;
                                disabled: boolean;
                                multiple: boolean;
                                isOpen: boolean;
                                noClear: boolean;
                                collapseChips: boolean;
                                closableChips: boolean;
                                isEmpty: boolean;
                                selectedOptions: OptionItem[];
                            },
                            {},
                            {
                                VsChip: DefineComponent<
                                    ExtractPropTypes<{
                                        closable: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        outline: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        primary: {
                                            type: BooleanConstructor;
                                            default: boolean;
                                        };
                                        size: {
                                            type: PropType<Size>;
                                            default: string;
                                        };
                                        styleSet: {
                                            type: PropType<string | VsChipStyleSet>;
                                        };
                                        colorScheme: {
                                            type: PropType<ColorScheme>;
                                        };
                                    }>,
                                    {
                                        colorSchemeClass: ComputedRef<string>;
                                        componentStyleSet: ComputedRef<Partial<VsChipStyleSet>>;
                                        styleSetVariables: ComputedRef<Record<string, string>>;
                                        componentInlineStyle: ComputedRef<CSSProperties>;
                                        classObj: ComputedRef<{
                                            [x: string]: boolean;
                                            'vs-outline': boolean;
                                            'vs-primary': boolean;
                                        }>;
                                    },
                                    {},
                                    {},
                                    {},
                                    ComponentOptionsMixin,
                                    ComponentOptionsMixin,
                                    'close'[],
                                    'close',
                                    PublicProps,
                                    Readonly<
                                        ExtractPropTypes<{
                                            closable: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            outline: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            primary: {
                                                type: BooleanConstructor;
                                                default: boolean;
                                            };
                                            size: {
                                                type: PropType<Size>;
                                                default: string;
                                            };
                                            styleSet: {
                                                type: PropType<string | VsChipStyleSet>;
                                            };
                                            colorScheme: {
                                                type: PropType<ColorScheme>;
                                            };
                                        }>
                                    > &
                                        Readonly<{
                                            onClose?: ((...args: any[]) => any) | undefined;
                                        }>,
                                    {
                                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                                        outline: boolean;
                                        primary: boolean;
                                        closable: boolean;
                                    },
                                    {},
                                    {
                                        XIcon: LucideIcon;
                                    },
                                    {},
                                    string,
                                    ComponentProvideOptions,
                                    true,
                                    {},
                                    any
                                >;
                                ChevronDownIcon: LucideIcon;
                                XIcon: LucideIcon;
                            },
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsGrid: DefineComponent<
            ExtractPropTypes<{
                width: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                height: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsGridStyleSet>;
                };
                gridSize: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                columnGap: {
                    type: (StringConstructor | NumberConstructor)[];
                };
                rowGap: {
                    type: (StringConstructor | NumberConstructor)[];
                };
            }>,
            {
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    width: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    height: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsGridStyleSet>;
                    };
                    gridSize: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    columnGap: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                    rowGap: {
                        type: (StringConstructor | NumberConstructor)[];
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsResponsive: DefineComponent<
            ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                responsiveClasses: ComputedRef<string[]>;
                responsiveStyles: ComputedRef<Record<string, string>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsTableBodyCell<I = VsTableItem> extends VsTableCell<I> {
    tag: 'td';
    item: I;
}

export declare interface VsTableCell<I = VsTableItem> {
    tag: VsTableTag;
    id: string;
    value: unknown;
    colKey: VsTableColumnKey<I>;
    rowIdx: number;
    colIdx: number;
}

export declare interface VsTableColumnDef<I = VsTableItem> {
    key: VsTableColumnKey<I>;
    label: string;
    headerAlign?: TextAlignment;
    align?: TextAlignment;
    verticalAlign?: VerticalAlignment;
    minWidth?: SizeProp;
    maxWidth?: SizeProp;
    width?: SizeProp;
    sortable?: boolean;
    sortBy?: VsTableColumnKey<I>;
    skipSearch?: boolean;
    transform?: (value: any, item: I) => unknown;
}

/**
 * NOTE: If I is `{ user: { name: { first: 'John' } } }`, then `ColumnKey<I>` is `'user' | 'user.name' | 'user.name.first'`
 */
export declare type VsTableColumnKey<I = VsTableItem> = JoinDotField<I>;

export declare interface VsTableHeaderCell extends VsTableCell {
    tag: 'th';
    sortable: boolean;
}

export declare type VsTableItem = any;

export declare type VsTablePageSizeOption = {
    label: string;
    value: number;
};

export declare type VsTablePageSizeOptions = VsTablePageSizeOption[];

export declare interface VsTablePaginationOptions {
    pageSizeOptions?: VsTablePageSizeOptions;
    showPageSizeSelect?: boolean;
    showingLength?: number;
    edgeButtons?: boolean;
    showTotal?: boolean;
    totalItemCount?: number;
}

export declare interface VsTableRef extends ComponentPublicInstance<typeof VsTable> {
    expand: (index: number) => void;
    collapse: (index: number) => void;
}

export declare enum VsTableSortType {
    NONE = 0,
    ASCEND = 1,
    DESCEND = 2,
}

export declare interface VsTableStyleSet extends CSSProperties {
    $toolbar?: CSSProperties;
    $search?: VsSearchInputStyleSet;
    $caption?: CSSProperties;
    $header?: CSSProperties;
    $stickyHeaderTop?: string;
    $row?: CSSProperties & {
        $selected?: CSSProperties;
    };
    $cell?: CSSProperties;
    $pagination?: VsPaginationStyleSet;
    $pageSizeSelect?: VsSelectStyleSet;
}

export declare type VsTableTag = 'td' | 'th';

export declare const VsTabs: DefineComponent<
    ExtractPropTypes<{
        controls: {
            type: PropType<'hide' | 'show' | 'auto'>;
            default: string;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        disabled: {
            type: PropType<boolean | ((tab: string, index: number) => boolean)>;
            default: boolean;
        };
        height: {
            type: (StringConstructor | NumberConstructor)[];
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        tabs: {
            type: PropType<string[]>;
            default: () => never[];
        };
        vertical: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: NumberConstructor;
            default: number;
        };
        styleSet: {
            type: PropType<string | VsTabsStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsTabsStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        classObj: ComputedRef<{
            [x: string]: boolean;
            'vs-primary': boolean;
            'vs-vertical': boolean;
        }>;
        getTabStyleSet: (index: number) => CSSProperties;
        isSelected: (index: number) => boolean;
        isDisabled: (index: number) => boolean;
        isAllDisabled: () => boolean;
        selectedIndex: Ref<number, number>;
        selectTab: (index: number) => void;
        isFirstEdge: ComputedRef<boolean>;
        isLastEdge: ComputedRef<boolean>;
        tabsRef: Ref<HTMLElement | null, HTMLElement | null>;
        handleKeydown: (e: KeyboardEvent, isVertical: boolean) => void;
        showControls: ComputedRef<boolean>;
        goPrev: () => void;
        goNext: () => void;
        indicatorStyle: Ref<Record<string, string> | null, Record<string, string> | null>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('change' | 'update:modelValue')[],
    'change' | 'update:modelValue',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            controls: {
                type: PropType<'hide' | 'show' | 'auto'>;
                default: string;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            disabled: {
                type: PropType<boolean | ((tab: string, index: number) => boolean)>;
                default: boolean;
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            tabs: {
                type: PropType<string[]>;
                default: () => never[];
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            modelValue: {
                type: NumberConstructor;
                default: number;
            };
            styleSet: {
                type: PropType<string | VsTabsStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
        }>
    > &
        Readonly<{
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        disabled: boolean | ((tab: string, index: number) => boolean);
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        vertical: boolean;
        primary: boolean;
        modelValue: number;
        controls: 'auto' | 'hide' | 'show';
        tabs: string[];
    },
    {},
    {
        VsButton: DefineComponent<
            ExtractPropTypes<{
                circle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<'button' | 'submit' | 'reset'>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsButtonStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    [x: string]: boolean;
                    'vs-focus-visible': boolean;
                    'vs-circle': boolean;
                    'vs-disabled': boolean;
                    'vs-ghost': boolean;
                    'vs-loading-state': boolean;
                    'vs-outline': boolean;
                    'vs-primary': boolean;
                    'vs-responsive': boolean;
                }>;
                buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsButtonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                circle: boolean;
                disabled: boolean;
                type: 'button' | 'reset' | 'submit';
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                outline: boolean;
                primary: boolean;
                ghost: boolean;
                loading: boolean;
                responsive: boolean;
            },
            {},
            {
                VsLoading: DefineComponent<
                    ExtractPropTypes<{
                        width: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        styleSet: {
                            type: PropType<string | VsLoadingStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {},
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsResponsive: DefineComponent<
            ExtractPropTypes<{
                tag: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                responsiveClasses: ComputedRef<string[]>;
                responsiveStyles: ComputedRef<Record<string, string>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    tag: {
                        type: StringConstructor;
                        default: string;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                tag: string;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        ChevronLeftIcon: LucideIcon;
        ChevronRightIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsTabsRef extends ComponentPublicInstance<typeof VsTabs> {
    goPrev: () => void;
    goNext: () => void;
}

export declare interface VsTabsStyleSet extends CSSProperties {
    $divider?: CSSProperties['border'] & {};
    $tabs?: CSSProperties;
    $tab?: CSSProperties & {
        $active?: CSSProperties;
    };
    $control?: Omit<VsButtonStyleSet, '$loading'>;
}

export declare const VsTextarea: DefineComponent<
    ExtractPropTypes<{
        autocomplete: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        modelValue: {
            type: StringConstructor;
            default: string;
        };
        modelModifiers: {
            type: PropType<StringModifiers>;
            default: () => {};
        };
        min: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        max: {
            type: PropType<number | string>;
            default: string | number;
            validator: (value: number | string) => boolean;
        };
        width: {
            type: PropType<string | number | Breakpoints>;
        };
        grid: {
            type: PropType<string | number | Breakpoints>;
        };
        styleSet: {
            type: PropType<string | VsTextareaStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
        label: {
            type: typeof String;
            default: string;
        };
        messages: {
            type: PropType<Message<string>[]>;
            default: () => Message<string>[];
        };
        name: {
            type: typeof String;
            default: string;
        };
        noDefaultRules: {
            type: typeof Boolean;
            default: boolean;
        };
        placeholder: {
            type: typeof String;
            default: string;
        };
        readonly: {
            type: typeof Boolean;
            default: boolean;
        };
        rules: {
            type: PropType<Rule<string>[]>;
            default: () => Rule<string>[];
        };
        state: {
            type: PropType<UIState>;
            default: UIState;
        };
        changed: {
            type: typeof Boolean;
            default: boolean;
        };
        valid: {
            type: typeof Boolean;
            default: boolean;
        };
        disabled: {
            type: typeof Boolean;
            default: boolean;
        };
        hidden: {
            type: typeof Boolean;
            default: boolean;
        };
        id: {
            type: typeof String;
            default: string;
        };
        noLabel: {
            type: typeof Boolean;
            default: boolean;
        };
        noMessages: {
            type: typeof Boolean;
            default: boolean;
        };
        required: {
            type: typeof Boolean;
            default: boolean;
        };
    }>,
    {
        textareaRef: Readonly<ShallowRef<HTMLTextAreaElement | null>>;
        classObj: ComputedRef<{
            'vs-disabled': boolean;
            'vs-readonly': boolean;
            'vs-focus-visible': boolean;
        }>;
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsTextareaStyleSet>>;
        sizeClass: ComputedRef<string>;
        stateBoxClasses: ComputedRef<{}>;
        computedId: ComputedRef<string>;
        computedDisabled: ComputedRef<boolean>;
        computedReadonly: ComputedRef<boolean>;
        computedMessages: ComputedRef<StateMessage<UIState>[]>;
        computedState: ComputedRef<UIState>;
        inputValue: Ref<string, string>;
        shake: Ref<boolean, boolean>;
        updateValue: (event: Event) => void;
        onFocus: (e: FocusEvent) => void;
        onBlur: (e: FocusEvent) => void;
        clear: () => void;
        reset: () => void;
        validate: () => boolean;
        focus: () => void;
        blur: () => void;
        select: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid')[],
    'blur' | 'change' | 'focus' | 'clear' | 'update:modelValue' | 'update:changed' | 'update:valid',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            autocomplete: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            modelValue: {
                type: StringConstructor;
                default: string;
            };
            modelModifiers: {
                type: PropType<StringModifiers>;
                default: () => {};
            };
            min: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            max: {
                type: PropType<number | string>;
                default: string | number;
                validator: (value: number | string) => boolean;
            };
            width: {
                type: PropType<string | number | Breakpoints>;
            };
            grid: {
                type: PropType<string | number | Breakpoints>;
            };
            styleSet: {
                type: PropType<string | VsTextareaStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
            label: {
                type: typeof String;
                default: string;
            };
            messages: {
                type: PropType<Message<string>[]>;
                default: () => Message<string>[];
            };
            name: {
                type: typeof String;
                default: string;
            };
            noDefaultRules: {
                type: typeof Boolean;
                default: boolean;
            };
            placeholder: {
                type: typeof String;
                default: string;
            };
            readonly: {
                type: typeof Boolean;
                default: boolean;
            };
            rules: {
                type: PropType<Rule<string>[]>;
                default: () => Rule<string>[];
            };
            state: {
                type: PropType<UIState>;
                default: UIState;
            };
            changed: {
                type: typeof Boolean;
                default: boolean;
            };
            valid: {
                type: typeof Boolean;
                default: boolean;
            };
            disabled: {
                type: typeof Boolean;
                default: boolean;
            };
            hidden: {
                type: typeof Boolean;
                default: boolean;
            };
            id: {
                type: typeof String;
                default: string;
            };
            noLabel: {
                type: typeof Boolean;
                default: boolean;
            };
            noMessages: {
                type: typeof Boolean;
                default: boolean;
            };
            required: {
                type: typeof Boolean;
                default: boolean;
            };
        }>
    > &
        Readonly<{
            onFocus?: ((...args: any[]) => any) | undefined;
            onBlur?: ((...args: any[]) => any) | undefined;
            onChange?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
            onClear?: ((...args: any[]) => any) | undefined;
            'onUpdate:changed'?: ((...args: any[]) => any) | undefined;
            'onUpdate:valid'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        label: string;
        messages: Message<string>[];
        name: string;
        noDefaultRules: boolean;
        placeholder: string;
        readonly: boolean;
        rules: Rule<string>[];
        state: UIState;
        changed: boolean;
        valid: boolean;
        disabled: boolean;
        hidden: boolean;
        id: string;
        noLabel: boolean;
        noMessages: boolean;
        required: boolean;
        min: string | number;
        max: string | number;
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        modelValue: string;
        autocomplete: boolean;
        modelModifiers: StringModifiers;
    },
    {},
    {
        VsInputWrapper: DefineComponent<
            ExtractPropTypes<{
                groupLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                messages: {
                    type: PropType<StateMessage<UIState>[]>;
                    default: () => never[];
                };
                shake: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                styleSet: {
                    type: PropType<string | VsInputWrapperStyleSet>;
                };
                disabled: {
                    type: typeof Boolean;
                    default: boolean;
                };
                hidden: {
                    type: typeof Boolean;
                    default: boolean;
                };
                id: {
                    type: typeof String;
                    default: string;
                };
                label: {
                    type: typeof String;
                    default: string;
                };
                noLabel: {
                    type: typeof Boolean;
                    default: boolean;
                };
                noMessages: {
                    type: typeof Boolean;
                    default: boolean;
                };
                required: {
                    type: typeof Boolean;
                    default: boolean;
                };
                width: {
                    type: PropType<string | number | Breakpoints>;
                };
                grid: {
                    type: PropType<string | number | Breakpoints>;
                };
            }>,
            {
                needToShake: Ref<boolean, boolean>;
                componentStyleSet: ComputedRef<Partial<VsInputWrapperStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    groupLabel: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    messages: {
                        type: PropType<StateMessage<UIState>[]>;
                        default: () => never[];
                    };
                    shake: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    styleSet: {
                        type: PropType<string | VsInputWrapperStyleSet>;
                    };
                    disabled: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    hidden: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    id: {
                        type: typeof String;
                        default: string;
                    };
                    label: {
                        type: typeof String;
                        default: string;
                    };
                    noLabel: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    noMessages: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    required: {
                        type: typeof Boolean;
                        default: boolean;
                    };
                    width: {
                        type: PropType<string | number | Breakpoints>;
                    };
                    grid: {
                        type: PropType<string | number | Breakpoints>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                label: string;
                messages: StateMessage<UIState>[];
                disabled: boolean;
                hidden: boolean;
                id: string;
                noLabel: boolean;
                noMessages: boolean;
                required: boolean;
                groupLabel: boolean;
                shake: boolean;
            },
            {},
            {
                VsResponsive: DefineComponent<
                    ExtractPropTypes<{
                        tag: {
                            type: StringConstructor;
                            default: string;
                        };
                        width: {
                            type: PropType<string | number | Breakpoints>;
                        };
                        grid: {
                            type: PropType<string | number | Breakpoints>;
                        };
                    }>,
                    {
                        responsiveClasses: ComputedRef<string[]>;
                        responsiveStyles: ComputedRef<Record<string, string>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            tag: {
                                type: StringConstructor;
                                default: string;
                            };
                            width: {
                                type: PropType<string | number | Breakpoints>;
                            };
                            grid: {
                                type: PropType<string | number | Breakpoints>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        tag: string;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                VsMessage: DefineComponent<
                    ExtractPropTypes<{
                        state: {
                            type: PropType<UIState>;
                            default: string;
                        };
                        text: {
                            type: StringConstructor;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsMessageStyleSet>;
                        };
                    }>,
                    {
                        colorClass: ComputedRef<
                            'vs-cs-blue' | 'vs-cs-green' | 'vs-cs-amber' | 'vs-cs-red' | 'vs-cs-default'
                        >;
                        icon: ComputedRef<Component>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            state: {
                                type: PropType<UIState>;
                                default: string;
                            };
                            text: {
                                type: StringConstructor;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsMessageStyleSet>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        text: string;
                        state: UIState;
                    },
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsTextareaRef extends ComponentPublicInstance<typeof VsTextarea>, FocusableRef, FormChildRef {
    select: () => void;
}

export declare interface VsTextareaStyleSet {
    $textarea?: CSSProperties;
    $wrapper?: VsInputWrapperStyleSet;
}

export declare type VsTextareaValueType = string;

export declare const VsTextWrap: DefineComponent<
    ExtractPropTypes<{
        copy: {
            type: BooleanConstructor;
            default: boolean;
        };
        link: {
            type: StringConstructor;
            default: string;
        };
        width: {
            type: PropType<string | number>;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsTextWrapStyleSet>;
        };
    }>,
    {
        componentStyleSet: ComputedRef<Partial<VsTextWrapStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        contentText: ComputedRef<string>;
        contentsRef: Ref<HTMLElement | null, HTMLElement | null>;
        copyInnerText: () => Promise<void>;
        openLink: () => void;
        copied: Ref<boolean, boolean>;
        CheckIcon: LucideIcon;
        CopyIcon: LucideIcon;
        LinkIcon: LucideIcon;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'copied'[],
    'copied',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            copy: {
                type: BooleanConstructor;
                default: boolean;
            };
            link: {
                type: StringConstructor;
                default: string;
            };
            width: {
                type: PropType<string | number>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsTextWrapStyleSet>;
            };
        }>
    > &
        Readonly<{
            onCopied?: ((...args: any[]) => any) | undefined;
        }>,
    {
        link: string;
        copy: boolean;
        width: string | number;
    },
    {},
    {
        LinkIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsTextWrapRef extends ComponentPublicInstance<typeof VsTextWrap> {}

export declare interface VsTextWrapStyleSet extends CSSProperties {
    $copyIcon?: CSSProperties;
    $linkIcon?: CSSProperties;
}

export declare const VsThemeButton: DefineComponent<
    ExtractPropTypes<{
        circle: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        ghost: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        outline: {
            type: BooleanConstructor;
            default: boolean;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        responsive: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        type: {
            type: PropType<'button' | 'submit' | 'reset'>;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsThemeButtonStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        changeTheme: (isDark: boolean) => void;
        isDarkTheme: ComputedRef<boolean>;
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsThemeButtonStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'change'[],
    'change',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            circle: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            ghost: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            type: {
                type: PropType<'button' | 'submit' | 'reset'>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsThemeButtonStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onChange?: ((...args: any[]) => any) | undefined;
        }>,
    {
        circle: boolean;
        disabled: boolean;
        type: 'button' | 'reset' | 'submit';
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        outline: boolean;
        primary: boolean;
        ghost: boolean;
        loading: boolean;
        responsive: boolean;
    },
    {},
    {
        VsToggle: DefineComponent<
            ExtractPropTypes<{
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                circle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<'button' | 'submit' | 'reset'>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsToggleStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                toggle: () => void;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            ('toggle' | 'update:modelValue')[],
            'toggle' | 'update:modelValue',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsToggleStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    onToggle?: ((...args: any[]) => any) | undefined;
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                circle: boolean;
                disabled: boolean;
                type: 'button' | 'reset' | 'submit';
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                outline: boolean;
                primary: boolean;
                modelValue: boolean;
                ghost: boolean;
                loading: boolean;
                responsive: boolean;
            },
            {},
            {
                VsButton: DefineComponent<
                    ExtractPropTypes<{
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsButtonStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                        classObj: ComputedRef<{
                            [x: string]: boolean;
                            'vs-focus-visible': boolean;
                            'vs-circle': boolean;
                            'vs-disabled': boolean;
                            'vs-ghost': boolean;
                            'vs-loading-state': boolean;
                            'vs-outline': boolean;
                            'vs-primary': boolean;
                            'vs-responsive': boolean;
                        }>;
                        buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                        componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsButtonStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        circle: boolean;
                        disabled: boolean;
                        type: 'button' | 'reset' | 'submit';
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        outline: boolean;
                        primary: boolean;
                        ghost: boolean;
                        loading: boolean;
                        responsive: boolean;
                    },
                    {},
                    {
                        VsLoading: DefineComponent<
                            ExtractPropTypes<{
                                width: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                height: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                styleSet: {
                                    type: PropType<string | VsLoadingStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                colorSchemeClass: ComputedRef<string>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    width: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    height: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    styleSet: {
                                        type: PropType<string | VsLoadingStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {},
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        MoonIcon: LucideIcon;
        SunIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

declare interface VsThemeButtonStyleSet extends VsToggleStyleSet {
    $iconSize?: string;
    $iconColor?: string;
}

export declare const VsToast: DefineComponent<
    ExtractPropTypes<{
        autoClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        timeout: {
            type: NumberConstructor;
            default: number;
        };
        styleSet: {
            type: PropType<string | VsToastStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        computedColorScheme: ComputedRef<
            | 'brown'
            | 'red'
            | 'orange'
            | 'amber'
            | 'yellow'
            | 'lime'
            | 'green'
            | 'emerald'
            | 'teal'
            | 'cyan'
            | 'sky'
            | 'blue'
            | 'indigo'
            | 'violet'
            | 'purple'
            | 'fuchsia'
            | 'pink'
            | 'rose'
            | 'gray'
            | 'none'
            | undefined
        >;
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsToastStyleSet>>;
        componentInlineStyle: ComputedRef<CSSProperties>;
        onMouseEnter: () => void;
        onMouseLeave: () => void;
        holdToClose: Ref<boolean, boolean>;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    'close'[],
    'close',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            autoClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            timeout: {
                type: NumberConstructor;
                default: number;
            };
            styleSet: {
                type: PropType<string | VsToastStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onClose?: ((...args: any[]) => any) | undefined;
        }>,
    {
        primary: boolean;
        autoClose: boolean;
        timeout: number;
    },
    {},
    {
        VsButton: DefineComponent<
            ExtractPropTypes<{
                circle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<'button' | 'submit' | 'reset'>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsButtonStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    [x: string]: boolean;
                    'vs-focus-visible': boolean;
                    'vs-circle': boolean;
                    'vs-disabled': boolean;
                    'vs-ghost': boolean;
                    'vs-loading-state': boolean;
                    'vs-outline': boolean;
                    'vs-primary': boolean;
                    'vs-responsive': boolean;
                }>;
                buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsButtonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                circle: boolean;
                disabled: boolean;
                type: 'button' | 'reset' | 'submit';
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                outline: boolean;
                primary: boolean;
                ghost: boolean;
                loading: boolean;
                responsive: boolean;
            },
            {},
            {
                VsLoading: DefineComponent<
                    ExtractPropTypes<{
                        width: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        styleSet: {
                            type: PropType<string | VsLoadingStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {},
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        XIcon: LucideIcon;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsToastRef extends ComponentPublicInstance<typeof VsToast> {}

export declare interface VsToastStyleSet extends CSSProperties {
    $closeButton?: Omit<VsButtonStyleSet, '$loading'>;
}

export declare const VsToastView: DefineComponent<
    ExtractPropTypes<{
        container: {
            type: StringConstructor;
            default: string;
        };
    }>,
    {
        toastsByPosition: ComputedRef<Record<string, ToastInfo[]>>;
        isFixed: ComputedRef<boolean>;
        removeToast: (id: string) => void;
        getPositionClass: (key: string) => string[];
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            container: {
                type: StringConstructor;
                default: string;
            };
        }>
    > &
        Readonly<{}>,
    {
        container: string;
    },
    {},
    {
        VsToast: DefineComponent<
            ExtractPropTypes<{
                autoClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                timeout: {
                    type: NumberConstructor;
                    default: number;
                };
                styleSet: {
                    type: PropType<string | VsToastStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                computedColorScheme: ComputedRef<
                    | 'brown'
                    | 'red'
                    | 'orange'
                    | 'amber'
                    | 'yellow'
                    | 'lime'
                    | 'green'
                    | 'emerald'
                    | 'teal'
                    | 'cyan'
                    | 'sky'
                    | 'blue'
                    | 'indigo'
                    | 'violet'
                    | 'purple'
                    | 'fuchsia'
                    | 'pink'
                    | 'rose'
                    | 'gray'
                    | 'none'
                    | undefined
                >;
                colorSchemeClass: ComputedRef<string>;
                componentStyleSet: ComputedRef<Partial<VsToastStyleSet>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                onMouseEnter: () => void;
                onMouseLeave: () => void;
                holdToClose: Ref<boolean, boolean>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            'close'[],
            'close',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    autoClose: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    timeout: {
                        type: NumberConstructor;
                        default: number;
                    };
                    styleSet: {
                        type: PropType<string | VsToastStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{
                    onClose?: ((...args: any[]) => any) | undefined;
                }>,
            {
                primary: boolean;
                autoClose: boolean;
                timeout: number;
            },
            {},
            {
                VsButton: DefineComponent<
                    ExtractPropTypes<{
                        circle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        ghost: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outline: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        primary: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        responsive: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        size: {
                            type: PropType<Size>;
                            default: string;
                        };
                        type: {
                            type: PropType<'button' | 'submit' | 'reset'>;
                            default: string;
                        };
                        styleSet: {
                            type: PropType<string | VsButtonStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                        classObj: ComputedRef<{
                            [x: string]: boolean;
                            'vs-focus-visible': boolean;
                            'vs-circle': boolean;
                            'vs-disabled': boolean;
                            'vs-ghost': boolean;
                            'vs-loading-state': boolean;
                            'vs-outline': boolean;
                            'vs-primary': boolean;
                            'vs-responsive': boolean;
                        }>;
                        buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                        componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            circle: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            ghost: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            outline: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            primary: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            responsive: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            size: {
                                type: PropType<Size>;
                                default: string;
                            };
                            type: {
                                type: PropType<'button' | 'submit' | 'reset'>;
                                default: string;
                            };
                            styleSet: {
                                type: PropType<string | VsButtonStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {
                        circle: boolean;
                        disabled: boolean;
                        type: 'button' | 'reset' | 'submit';
                        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                        outline: boolean;
                        primary: boolean;
                        ghost: boolean;
                        loading: boolean;
                        responsive: boolean;
                    },
                    {},
                    {
                        VsLoading: DefineComponent<
                            ExtractPropTypes<{
                                width: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                height: {
                                    type: (StringConstructor | NumberConstructor)[];
                                };
                                styleSet: {
                                    type: PropType<string | VsLoadingStyleSet>;
                                };
                                colorScheme: {
                                    type: PropType<ColorScheme>;
                                };
                            }>,
                            {
                                colorSchemeClass: ComputedRef<string>;
                                styleSetVariables: ComputedRef<Record<string, string>>;
                                componentInlineStyle: ComputedRef<CSSProperties>;
                            },
                            {},
                            {},
                            {},
                            ComponentOptionsMixin,
                            ComponentOptionsMixin,
                            {},
                            string,
                            PublicProps,
                            Readonly<
                                ExtractPropTypes<{
                                    width: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    height: {
                                        type: (StringConstructor | NumberConstructor)[];
                                    };
                                    styleSet: {
                                        type: PropType<string | VsLoadingStyleSet>;
                                    };
                                    colorScheme: {
                                        type: PropType<ColorScheme>;
                                    };
                                }>
                            > &
                                Readonly<{}>,
                            {},
                            {},
                            {},
                            {},
                            string,
                            ComponentProvideOptions,
                            true,
                            {},
                            any
                        >;
                    },
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
                XIcon: LucideIcon;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
        VsRender: DefineComponent<
            ExtractPropTypes<{
                content: {
                    type: PropType<string | Component>;
                    required: true;
                };
                componentProps: {
                    type: PropType<Record<string, any>>;
                    default: () => {};
                };
            }>,
            () => VNode<
                RendererNode,
                RendererElement,
                {
                    [key: string]: any;
                }
            >,
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    content: {
                        type: PropType<string | Component>;
                        required: true;
                    };
                    componentProps: {
                        type: PropType<Record<string, any>>;
                        default: () => {};
                    };
                }>
            > &
                Readonly<{}>,
            {
                componentProps: Record<string, any>;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsToastViewRef extends ComponentPublicInstance<typeof VsToastView> {}

export declare const VsToggle: DefineComponent<
    ExtractPropTypes<{
        modelValue: {
            type: BooleanConstructor;
            default: boolean;
        };
        circle: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        ghost: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        outline: {
            type: BooleanConstructor;
            default: boolean;
        };
        primary: {
            type: BooleanConstructor;
            default: boolean;
        };
        responsive: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: PropType<Size>;
            default: string;
        };
        type: {
            type: PropType<'button' | 'submit' | 'reset'>;
            default: string;
        };
        styleSet: {
            type: PropType<string | VsToggleStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        componentStyleSet: ComputedRef<Partial<VsToggleStyleSet>>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        toggle: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    ('toggle' | 'update:modelValue')[],
    'toggle' | 'update:modelValue',
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            modelValue: {
                type: BooleanConstructor;
                default: boolean;
            };
            circle: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            ghost: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            primary: {
                type: BooleanConstructor;
                default: boolean;
            };
            responsive: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: PropType<Size>;
                default: string;
            };
            type: {
                type: PropType<'button' | 'submit' | 'reset'>;
                default: string;
            };
            styleSet: {
                type: PropType<string | VsToggleStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{
            onToggle?: ((...args: any[]) => any) | undefined;
            'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
        }>,
    {
        circle: boolean;
        disabled: boolean;
        type: 'button' | 'reset' | 'submit';
        size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
        outline: boolean;
        primary: boolean;
        modelValue: boolean;
        ghost: boolean;
        loading: boolean;
        responsive: boolean;
    },
    {},
    {
        VsButton: DefineComponent<
            ExtractPropTypes<{
                circle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                ghost: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                primary: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                responsive: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                size: {
                    type: PropType<Size>;
                    default: string;
                };
                type: {
                    type: PropType<'button' | 'submit' | 'reset'>;
                    default: string;
                };
                styleSet: {
                    type: PropType<string | VsButtonStyleSet>;
                };
                colorScheme: {
                    type: PropType<ColorScheme>;
                };
            }>,
            {
                colorSchemeClass: ComputedRef<string>;
                styleSetVariables: ComputedRef<Record<string, string>>;
                componentInlineStyle: ComputedRef<CSSProperties>;
                classObj: ComputedRef<{
                    [x: string]: boolean;
                    'vs-focus-visible': boolean;
                    'vs-circle': boolean;
                    'vs-disabled': boolean;
                    'vs-ghost': boolean;
                    'vs-loading-state': boolean;
                    'vs-outline': boolean;
                    'vs-primary': boolean;
                    'vs-responsive': boolean;
                }>;
                buttonRef: Readonly<ShallowRef<HTMLButtonElement | null>>;
                componentStyleSet: ComputedRef<Partial<VsButtonStyleSet>>;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            {},
            string,
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    circle: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    ghost: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    primary: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    responsive: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    size: {
                        type: PropType<Size>;
                        default: string;
                    };
                    type: {
                        type: PropType<'button' | 'submit' | 'reset'>;
                        default: string;
                    };
                    styleSet: {
                        type: PropType<string | VsButtonStyleSet>;
                    };
                    colorScheme: {
                        type: PropType<ColorScheme>;
                    };
                }>
            > &
                Readonly<{}>,
            {
                circle: boolean;
                disabled: boolean;
                type: 'button' | 'reset' | 'submit';
                size: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
                outline: boolean;
                primary: boolean;
                ghost: boolean;
                loading: boolean;
                responsive: boolean;
            },
            {},
            {
                VsLoading: DefineComponent<
                    ExtractPropTypes<{
                        width: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        height: {
                            type: (StringConstructor | NumberConstructor)[];
                        };
                        styleSet: {
                            type: PropType<string | VsLoadingStyleSet>;
                        };
                        colorScheme: {
                            type: PropType<ColorScheme>;
                        };
                    }>,
                    {
                        colorSchemeClass: ComputedRef<string>;
                        styleSetVariables: ComputedRef<Record<string, string>>;
                        componentInlineStyle: ComputedRef<CSSProperties>;
                    },
                    {},
                    {},
                    {},
                    ComponentOptionsMixin,
                    ComponentOptionsMixin,
                    {},
                    string,
                    PublicProps,
                    Readonly<
                        ExtractPropTypes<{
                            width: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            height: {
                                type: (StringConstructor | NumberConstructor)[];
                            };
                            styleSet: {
                                type: PropType<string | VsLoadingStyleSet>;
                            };
                            colorScheme: {
                                type: PropType<ColorScheme>;
                            };
                        }>
                    > &
                        Readonly<{}>,
                    {},
                    {},
                    {},
                    {},
                    string,
                    ComponentProvideOptions,
                    true,
                    {},
                    any
                >;
            },
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsToggleRef extends ComponentPublicInstance<typeof VsToggle> {
    toggle: () => void;
}

export declare interface VsToggleStyleSet extends VsButtonStyleSet {}

export declare const VsTooltip: DefineComponent<
    ExtractPropTypes<{
        target: {
            type: StringConstructor;
            default: string;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        clickable: {
            type: BooleanConstructor;
            default: boolean;
        };
        contentsHover: {
            type: BooleanConstructor;
            default: boolean;
        };
        escClose: {
            type: BooleanConstructor;
            default: boolean;
        };
        align: {
            type: PropType<Alignment>;
            default: 'start' | 'center' | 'end';
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        enterDelay: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        leaveDelay: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        margin: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        noAnimation: {
            type: BooleanConstructor;
            default: boolean;
        };
        placement: {
            type: PropType<Placement>;
            default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
        };
        styleSet: {
            type: PropType<string | VsTooltipStyleSet>;
        };
        colorScheme: {
            type: PropType<ColorScheme>;
        };
    }>,
    {
        colorSchemeClass: ComputedRef<string>;
        styleSetVariables: ComputedRef<Record<string, string>>;
        componentStyleSet: ComputedRef<Partial<VsTooltipStyleSet>>;
        computedShow: WritableComputedRef<boolean, boolean>;
        triggerClass: ComputedRef<string>;
        effectiveTarget: ComputedRef<string>;
        onTooltipEnter: () => void;
        onTooltipLeave: () => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            target: {
                type: StringConstructor;
                default: string;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            clickable: {
                type: BooleanConstructor;
                default: boolean;
            };
            contentsHover: {
                type: BooleanConstructor;
                default: boolean;
            };
            escClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            align: {
                type: PropType<Alignment>;
                default: 'start' | 'center' | 'end';
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            enterDelay: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            leaveDelay: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            margin: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            noAnimation: {
                type: BooleanConstructor;
                default: boolean;
            };
            placement: {
                type: PropType<Placement>;
                default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
            };
            styleSet: {
                type: PropType<string | VsTooltipStyleSet>;
            };
            colorScheme: {
                type: PropType<ColorScheme>;
            };
        }>
    > &
        Readonly<{}>,
    {
        disabled: boolean;
        margin: string | number;
        tag: string;
        target: string;
        placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
        escClose: boolean;
        align: 'start' | 'center' | 'end';
        enterDelay: string | number;
        leaveDelay: string | number;
        noAnimation: boolean;
        clickable: boolean;
        contentsHover: boolean;
    },
    {},
    {
        VsFloating: DefineComponent<
            ExtractPropTypes<{
                followWidth: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                overlayId: {
                    type: StringConstructor;
                    default: string;
                };
                modelValue: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                target: {
                    type: StringConstructor;
                    required: boolean;
                    default: string;
                };
                align: {
                    type: PropType<Alignment>;
                    default: 'start' | 'center' | 'end';
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                enterDelay: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                leaveDelay: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                margin: {
                    type: (StringConstructor | NumberConstructor)[];
                    default: number;
                };
                noAnimation: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                placement: {
                    type: PropType<Placement>;
                    default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                };
            }>,
            {
                floatingRef: Readonly<ShallowRef<HTMLElement | null>>;
                computedPlacement: Ref<
                    'top' | 'right' | 'bottom' | 'left' | 'middle' | null,
                    'top' | 'right' | 'bottom' | 'left' | 'middle' | null
                >;
                isVisible: Ref<boolean, boolean>;
                isFloated: Ref<boolean, boolean>;
                animationClass: ComputedRef<string | null>;
                floatingStyle: ComputedRef<
                    | {
                          animationDelay?: undefined;
                      }
                    | {
                          animationDelay: string;
                      }
                >;
            },
            {},
            {},
            {},
            ComponentOptionsMixin,
            ComponentOptionsMixin,
            'update:modelValue'[],
            'update:modelValue',
            PublicProps,
            Readonly<
                ExtractPropTypes<{
                    followWidth: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    overlayId: {
                        type: StringConstructor;
                        default: string;
                    };
                    modelValue: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    target: {
                        type: StringConstructor;
                        required: boolean;
                        default: string;
                    };
                    align: {
                        type: PropType<Alignment>;
                        default: 'start' | 'center' | 'end';
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    enterDelay: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    leaveDelay: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    margin: {
                        type: (StringConstructor | NumberConstructor)[];
                        default: number;
                    };
                    noAnimation: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    placement: {
                        type: PropType<Placement>;
                        default: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                    };
                }>
            > &
                Readonly<{
                    'onUpdate:modelValue'?: ((...args: any[]) => any) | undefined;
                }>,
            {
                disabled: boolean;
                margin: string | number;
                modelValue: boolean;
                target: string;
                placement: 'top' | 'right' | 'bottom' | 'left' | 'middle';
                overlayId: string;
                followWidth: boolean;
                align: 'start' | 'center' | 'end';
                enterDelay: string | number;
                leaveDelay: string | number;
                noAnimation: boolean;
            },
            {},
            {},
            {},
            string,
            ComponentProvideOptions,
            true,
            {},
            any
        >;
    },
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsTooltipRef extends ComponentPublicInstance<typeof VsTooltip> {}

export declare interface VsTooltipStyleSet {
    $arrowColor?: string;
    $arrowSize?: string;
    $tooltip?: CSSProperties;
    $trigger?: CSSProperties;
}

export declare const VsVisibleRender: DefineComponent<
    ExtractPropTypes<{
        selector: {
            type: StringConstructor;
            default: null;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        height: {
            type: (StringConstructor | NumberConstructor)[];
        };
        rootMargin: {
            type: StringConstructor;
            default: string;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        threshold: {
            type: NumberConstructor;
            default: number;
            validator: (value: number) => boolean;
        };
    }>,
    {
        containerStyle: ComputedRef<
            | {
                  height?: undefined;
                  overflowY?: undefined;
              }
            | {
                  height: string;
                  overflowY: string;
              }
        >;
        scrollToElement: (element: HTMLElement) => void;
    },
    {},
    {},
    {},
    ComponentOptionsMixin,
    ComponentOptionsMixin,
    {},
    string,
    PublicProps,
    Readonly<
        ExtractPropTypes<{
            selector: {
                type: StringConstructor;
                default: null;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            height: {
                type: (StringConstructor | NumberConstructor)[];
            };
            rootMargin: {
                type: StringConstructor;
                default: string;
            };
            tag: {
                type: StringConstructor;
                default: string;
            };
            threshold: {
                type: NumberConstructor;
                default: number;
                validator: (value: number) => boolean;
            };
        }>
    > &
        Readonly<{}>,
    {
        disabled: boolean;
        tag: string;
        selector: string;
        rootMargin: string;
        threshold: number;
    },
    {},
    {},
    {},
    string,
    ComponentProvideOptions,
    true,
    {},
    any
>;

export declare interface VsVisibleRenderRef extends ComponentPublicInstance<typeof VsVisibleRender> {
    scrollToElement: (element: HTMLElement) => void;
}

export {};

declare module 'vue' {
    interface ComponentCustomProperties {
        $vs: Vlossom;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsDatePicker: typeof VsDatePicker;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsAvatar: typeof VsAvatar;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsTable: typeof VsTable;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsExpandable: typeof VsExpandable;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsAccordion: typeof VsAccordion;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsBar: typeof VsBar;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsBlock: typeof VsBlock;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsInnerScroll: typeof VsInnerScroll;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsLoading: typeof VsLoading;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsButton: typeof VsButton;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsMessage: typeof VsMessage;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsInputWrapper: typeof VsInputWrapper;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsCheckbox: typeof VsCheckbox;
        VsCheckboxSet: typeof VsCheckboxSet;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsChip: typeof VsChip;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsContainer: typeof VsContainer;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsInput: typeof VsInput;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsDimmed: typeof VsDimmed;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsDivider: typeof VsDivider;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsDrawer: typeof VsDrawer;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsFileDrop: typeof VsFileDrop;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsFloating: typeof VsFloating;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsFocusTrap: typeof VsFocusTrap;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsFooter: typeof VsFooter;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsGrid: typeof VsGrid;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsForm: typeof VsForm;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsHeader: typeof VsHeader;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsSkeleton: typeof VsSkeleton;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsImage: typeof VsImage;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsIndexView: typeof VsIndexView;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsLabelValue: typeof VsLabelValue;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsLayout: typeof VsLayout;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsModal: typeof VsModal;
        VsModalNode: typeof VsModalNode;
        VsModalView: typeof VsModalView;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsVisibleRender: typeof VsVisibleRender;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsGroupedList: typeof VsGroupedList;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsPage: typeof VsPage;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsPagination: typeof VsPagination;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsProgress: typeof VsProgress;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsRadio: typeof VsRadio;
        VsRadioSet: typeof VsRadioSet;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsRender: typeof VsRender;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsResponsive: typeof VsResponsive;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsToggle: typeof VsToggle;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsSearchInput: typeof VsSearchInput;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsSelect: typeof VsSelect;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsSteps: typeof VsSteps;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsSwitch: typeof VsSwitch;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsTabs: typeof VsTabs;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsTextarea: typeof VsTextarea;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsTextWrap: typeof VsTextWrap;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsToast: typeof VsToast;
        VsToastView: typeof VsToastView;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsTooltip: typeof VsTooltip;
    }
}

declare module 'vue' {
    interface GlobalComponents {
        VsThemeButton: typeof VsThemeButton;
    }
}