@vueland/ui 0.0.1 → 0.0.2

package/dist/composables/index.d.ts

@@ -1,167 +1,5 @@
 import * as vue from 'vue';
-import { MaybeRef, Reactive, ComputedRef, ComponentPublicInstance, ShallowRef, ComponentInstance, FunctionalComponent, Directive, App, ShallowReactive } from 'vue';
-
-declare const breakpoints: {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    xxl: number;
-};
-interface AppBreakpoints {
-    xxl: MaybeRef<boolean>;
-    xl: MaybeRef<boolean>;
-    lg: MaybeRef<boolean>;
-    md: MaybeRef<boolean>;
-    sm: MaybeRef<boolean>;
-    xs: MaybeRef<boolean>;
-    xlAndLess: MaybeRef<boolean>;
-    lgAndLess: MaybeRef<boolean>;
-    mdAndLess: MaybeRef<boolean>;
-    smAndLess: MaybeRef<boolean>;
-    xlAndUp: MaybeRef<boolean>;
-    lgAndUp: MaybeRef<boolean>;
-    mdAndUp: MaybeRef<boolean>;
-    smAndUp: MaybeRef<boolean>;
-}
-declare function useDisplay(): {
-    state: {
-        xxl: boolean;
-        xl: boolean;
-        lg: boolean;
-        md: boolean;
-        sm: boolean;
-        xs: boolean;
-        xlAndLess: boolean;
-        lgAndLess: boolean;
-        mdAndLess: boolean;
-        smAndLess: boolean;
-        xlAndUp: boolean;
-        lgAndUp: boolean;
-        mdAndUp: boolean;
-        smAndUp: boolean;
-    };
-    createDisplay: (ssr?: boolean) => {
-        update: () => void;
-        xxl: vue.Ref<boolean, boolean>;
-        xl: vue.Ref<boolean, boolean>;
-        lg: vue.Ref<boolean, boolean>;
-        md: vue.Ref<boolean, boolean>;
-        sm: vue.Ref<boolean, boolean>;
-        xs: vue.Ref<boolean, boolean>;
-        xlAndLess: vue.Ref<boolean, boolean>;
-        lgAndLess: vue.Ref<boolean, boolean>;
-        mdAndLess: vue.Ref<boolean, boolean>;
-        smAndLess: vue.Ref<boolean, boolean>;
-        xlAndUp: vue.Ref<boolean, boolean>;
-        lgAndUp: vue.Ref<boolean, boolean>;
-        mdAndUp: vue.Ref<boolean, boolean>;
-        smAndUp: vue.Ref<boolean, boolean>;
-    };
-};
-
-type Maybe<T> = T | undefined;
-
-interface DimensionsProps {
-    width?: number | string;
-    height?: number | string;
-    minWidth?: number | string;
-    maxWidth?: number | string;
-    minHeight?: number | string;
-    maxHeight?: number | string;
-}
-
-type InputStateProps = {
-    disabled?: boolean;
-    focused?: boolean;
-    readonly?: boolean;
-};
-interface InputState {
-    focused: boolean;
-    isDirty: boolean;
-    hasValue: boolean;
-}
-declare function useInputState(props?: Record<string, any>): {
-    state: vue.ShallowReactive<InputState>;
-    onFocus: () => void;
-    onBlur: () => void;
-    onInput: () => void;
-};
-
-type ValidateFn = (value: any) => ({
-    valid: boolean;
-    message: string;
-});
-type ValidateOn = 'input' | 'blur';
-type ValidateProps = {
-    rules?: ValidateFn[];
-    validateOn?: ValidateOn;
-};
-type ValidateState = {
-    errorMessage: Maybe<string>;
-    hasError: boolean;
-};
-declare enum InputEvents {
-    INPUT = "input",
-    BLUR = "blur"
-}
-declare function useValidate(props: ValidateProps & {
-    modelValue: any;
-}, state: Reactive<InputState>): {
-    errors: {
-        errorMessage: Maybe<string>;
-        hasError: boolean;
-    };
-    hasRules: vue.ComputedRef<boolean>;
-    validate: () => boolean;
-};
-
-type ApplicationApi = {
-    blockScroll(): void;
-    unblockScroll(): void;
-    getScrollTop(): number;
-    getScrollLeft(): number;
-};
-
-type CBtnProps = PresetProps & {
-    variant?: 'flat' | 'outlined';
-    block?: boolean;
-};
-
-type ValidatorFn = () => boolean;
-interface FormApi {
-    add(fn: ValidatorFn): void;
-    remove(fn: ValidatorFn): void;
-}
-
-type CInputProps<T = any> = ValidateProps & InputStateProps & PresetProps & {
-    id?: string;
-    modelValue: T;
-    label?: string;
-    details?: string;
-    noDetails?: boolean;
-    clearable?: boolean;
-};
-
-type COverlayProps = {
-    modelValue: boolean;
-    to?: string;
-};
-
-type CMenuProps = ActivatorProps & CoordsProps & DimensionsProps & PositionProps & AutoPositionProps & DelayProps & PresetProps & Partial<COverlayProps> & {
-    closeOnClickOutside?: boolean;
-    closeOnContentClick?: boolean;
-    ssr?: boolean;
-    transition?: string;
-};
-
-declare function useFieldAttrs({ props, attrs, errors, uid }: {
-    props: CInputProps;
-    attrs: Record<string, any>;
-    errors: ValidateState;
-    uid: string;
-}): ComputedRef<Record<string, any>>;
+import { ComponentPublicInstance, PropType, ComputedRef, App, ComponentInstance, FunctionalComponent, Directive, ShallowRef, MaybeRef, Component, Reactive } from 'vue';
 
 type ActivatorProps = {
     closeOnClick?: boolean;
@@ -169,6 +7,7 @@ type ActivatorProps = {
     openOnHover?: boolean;
     closeOnLeave?: boolean;
     openOnFocus?: boolean;
+    activator?: ComponentPublicInstance | Element;
 };
 type ActivatorListeners = {
     mouseenter?: (e: Event) => void;
@@ -182,9 +21,162 @@ type ActivatorListeners = {
     input?: (e: Event) => void;
     change?: (e: Event) => void;
 };
+declare const makeActivatorProps: {
+    <TDefaults extends Partial<Record<"closeOnClick" | "openOnClick" | "openOnHover" | "closeOnLeave" | "openOnFocus" | "activator", unknown>>>(defaults: TDefaults): {
+        closeOnClick: "closeOnClick" extends infer T ? T extends "closeOnClick" ? T extends keyof TDefaults ? {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T] & {
+            default: TDefaults[T];
+        } : {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T] : never : never;
+        openOnClick: "openOnClick" extends infer T_1 ? T_1 extends "openOnClick" ? T_1 extends keyof TDefaults ? {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_1] & {
+            default: TDefaults[T_1];
+        } : {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_1] : never : never;
+        openOnHover: "openOnHover" extends infer T_2 ? T_2 extends "openOnHover" ? T_2 extends keyof TDefaults ? {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_2] & {
+            default: TDefaults[T_2];
+        } : {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_2] : never : never;
+        closeOnLeave: "closeOnLeave" extends infer T_3 ? T_3 extends "closeOnLeave" ? T_3 extends keyof TDefaults ? {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_3] & {
+            default: TDefaults[T_3];
+        } : {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_3] : never : never;
+        openOnFocus: "openOnFocus" extends infer T_4 ? T_4 extends "openOnFocus" ? T_4 extends keyof TDefaults ? {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_4] & {
+            default: TDefaults[T_4];
+        } : {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_4] : never : never;
+        activator: "activator" extends infer T_5 ? T_5 extends "activator" ? T_5 extends keyof TDefaults ? {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_5] & {
+            default: TDefaults[T_5];
+        } : {
+            closeOnClick: BooleanConstructor;
+            openOnClick: BooleanConstructor;
+            openOnHover: BooleanConstructor;
+            closeOnLeave: BooleanConstructor;
+            openOnFocus: BooleanConstructor;
+            activator: {
+                type: null;
+                default: undefined;
+            };
+        }[T_5] : never : never;
+    };
+    (): {
+        closeOnClick: BooleanConstructor;
+        openOnClick: BooleanConstructor;
+        openOnHover: BooleanConstructor;
+        closeOnLeave: BooleanConstructor;
+        openOnFocus: BooleanConstructor;
+        activator: {
+            type: null;
+            default: undefined;
+        };
+    };
+};
 declare function useActivator(props: Partial<ActivatorProps> & Record<string, unknown>): {
+    element: vue.ComputedRef<Element>;
     activatorProps: Record<string, any>;
-    getActivatorElement: () => HTMLElement;
     genListeners: ({ open, close, toggle, }: {
         open: () => void;
         close: () => void;
@@ -195,31 +187,113 @@ declare function useActivator(props: Partial<ActivatorProps> & Record<string, un
         mouseleave?: (() => void) | undefined;
         mouseenter?: (() => void) | undefined;
     }>>;
-    getActivator: <T>() => T;
+    getActivator: () => Element;
 };
 
-declare function useAutocomplete<T = any>(props: Record<string, any>): {
-    input: vue.ShallowRef<any, any>;
-    searchItems: vue.ComputedRef<any>;
-    rollbackValue: () => void;
+declare function useAppScroll(): {
+    appRef: vue.ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
+    classes: vue.ComputedRef<{
+        'c-app--block-scroll': boolean;
+    }>;
+    getScrollTop: () => number;
+    getScrollLeft: () => number;
+    blockScroll: () => void;
+    unblockScroll: () => void;
 };
 
-type Classes = 'to--left' | 'to--right' | 'to--top' | 'to--bottom';
-interface PositionProps {
-    left?: boolean;
-    right?: boolean;
-    top?: boolean;
-    bottom?: boolean;
+type ApplicationApi = {
+    blockScroll(): void;
+    unblockScroll(): void;
+    getScrollTop(): number;
+    getScrollLeft(): number;
+};
+
+interface InputState {
+    focused: boolean;
+    isDirty: boolean;
 }
-declare function usePositionClasses(props: PositionProps): vue.ComputedRef<Record<Classes, boolean>>;
+type CInputKind = 'checkbox' | 'radio' | 'input' | 'area' | 'listbox';
+type CInputProps<T = any> = ValidateProps & PresetProps & {
+    id?: string;
+    modelValue: T | T[] | undefined | null;
+    label?: string;
+    details?: string;
+    noDetails?: boolean;
+    clearable?: boolean;
+    disabled?: boolean;
+    focused?: boolean;
+    readonly?: boolean;
+    kind?: CInputKind;
+};
 
-type DelayProps = {
-    openDelay?: number | string;
-    closeDelay?: number | string;
+type CBtnProps = PresetProps & {
+    variant?: 'flat' | 'outlined';
+    block?: boolean;
+    disabled?: boolean;
 };
-declare function useDelayedActions(props: Partial<DelayProps> & Record<string, any>): {
-    openDelay: (fn: (...args: any) => any) => void;
-    closeDelay: (fn: (...args: any) => any) => void;
+
+type COverlayProps = {
+    modelValue: boolean;
+    to?: string;
+};
+
+type ValidatorFn = () => boolean | Promise<boolean>;
+type ResetFn = () => void;
+interface FormAPI {
+    add(fn: ValidatorFn): void;
+    remove(fn: ValidatorFn): void;
+    addReset(fn: ResetFn): void;
+    removeReset(fn: ResetFn): void;
+}
+
+interface DimensionsProps {
+    width?: number | string;
+    height?: number | string;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    maxHeight?: number | string;
+}
+
+type ThemeDefinition = {
+    primary?: string;
+    onPrimary?: string;
+    secondary?: string;
+    success?: string;
+    error?: string;
+    warning?: string;
+    info?: string;
+    accent?: string;
+    background?: string;
+    surface?: string;
+    surfaceVariant?: string;
+    onSurface?: string;
+    text?: string;
+    textSecondary?: string;
+    placeholder?: string;
+    disabled?: string;
+    disabledBg?: string;
+    disabledOpacity?: string;
+    readonly?: string;
+    readonlyBg?: string;
+    focus?: string;
+    errorBg?: string;
+    hover?: string;
+    overlay?: string;
+    shadow?: string;
+    border?: string;
+    radius?: string;
+    [key: string]: string | undefined;
+};
+type ThemesOptions = Record<string, ThemeDefinition>;
+
+type Maybe<T> = T | undefined;
+
+type CMenuProps = ActivatorProps & DimensionsProps & AutoPositionProps & DelayProps & PresetProps & Partial<COverlayProps> & {
+    closeOnClickOutside?: boolean;
+    closeOnContentClick?: boolean;
+    ssr?: boolean;
+    transition?: string;
 };
 
 declare function useApplication(): ApplicationApi;
@@ -230,16 +304,299 @@ interface Dimensions {
     width: number;
     height: number;
 }
-interface CoordsProps {
+interface AutoPositionProps {
+    strategy?: 'reverse' | 'bounce';
     positionX?: number;
     positionY?: number;
     offsetX?: number | string;
     offsetY?: number | string;
+    left?: boolean;
+    right?: boolean;
+    top?: boolean;
+    bottom?: boolean;
 }
-interface AutoPositionProps {
-    strategy?: 'reverse' | 'bounce';
-}
-declare function useAutoPosition(props: PositionProps & CoordsProps & DimensionsProps & AutoPositionProps): {
+type MaybeElement = Element | ComponentPublicInstance | undefined;
+type AutoPositionInputProps = DimensionsProps & AutoPositionProps;
+declare const makeAutoPositionProps: {
+    <TDefaults extends Partial<Record<"top" | "left" | "strategy" | "positionX" | "positionY" | "offsetX" | "offsetY" | "right" | "bottom", unknown>>>(defaults: TDefaults): {
+        strategy: "strategy" extends infer T ? T extends "strategy" ? T extends keyof TDefaults ? {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T] & {
+            default: TDefaults[T];
+        } : {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T] : never : never;
+        positionX: "positionX" extends infer T_1 ? T_1 extends "positionX" ? T_1 extends keyof TDefaults ? {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_1] & {
+            default: TDefaults[T_1];
+        } : {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_1] : never : never;
+        positionY: "positionY" extends infer T_2 ? T_2 extends "positionY" ? T_2 extends keyof TDefaults ? {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_2] & {
+            default: TDefaults[T_2];
+        } : {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_2] : never : never;
+        offsetX: "offsetX" extends infer T_3 ? T_3 extends "offsetX" ? T_3 extends keyof TDefaults ? {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_3] & {
+            default: TDefaults[T_3];
+        } : {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_3] : never : never;
+        offsetY: "offsetY" extends infer T_4 ? T_4 extends "offsetY" ? T_4 extends keyof TDefaults ? {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_4] & {
+            default: TDefaults[T_4];
+        } : {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_4] : never : never;
+        left: "left" extends infer T_5 ? T_5 extends "left" ? T_5 extends keyof TDefaults ? {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_5] & {
+            default: TDefaults[T_5];
+        } : {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_5] : never : never;
+        right: "right" extends infer T_6 ? T_6 extends "right" ? T_6 extends keyof TDefaults ? {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_6] & {
+            default: TDefaults[T_6];
+        } : {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_6] : never : never;
+        top: "top" extends infer T_7 ? T_7 extends "top" ? T_7 extends keyof TDefaults ? {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_7] & {
+            default: TDefaults[T_7];
+        } : {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_7] : never : never;
+        bottom: "bottom" extends infer T_8 ? T_8 extends "bottom" ? T_8 extends keyof TDefaults ? {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_8] & {
+            default: TDefaults[T_8];
+        } : {
+            strategy: {
+                type: PropType<AutoPositionProps["strategy"]>;
+                default: string;
+            };
+            positionX: NumberConstructor;
+            positionY: NumberConstructor;
+            offsetX: (StringConstructor | NumberConstructor)[];
+            offsetY: (StringConstructor | NumberConstructor)[];
+            left: BooleanConstructor;
+            right: BooleanConstructor;
+            top: BooleanConstructor;
+            bottom: BooleanConstructor;
+        }[T_8] : never : never;
+    };
+    (): {
+        strategy: {
+            type: PropType<AutoPositionProps["strategy"]>;
+            default: string;
+        };
+        positionX: NumberConstructor;
+        positionY: NumberConstructor;
+        offsetX: (StringConstructor | NumberConstructor)[];
+        offsetY: (StringConstructor | NumberConstructor)[];
+        left: BooleanConstructor;
+        right: BooleanConstructor;
+        top: BooleanConstructor;
+        bottom: BooleanConstructor;
+    };
+};
+declare function useAutoPosition(props: AutoPositionInputProps, activatorEl?: ComputedRef<MaybeElement>): {
     activator: vue.Ref<{
         top: number;
         left: number;
@@ -262,46 +619,141 @@ declare function useAutoPosition(props: PositionProps & CoordsProps & Dimensions
         width: number;
         height: number;
     }>;
-    contentRef: vue.ShallowRef<HTMLElement | ComponentPublicInstance | undefined, HTMLElement | ComponentPublicInstance | undefined>;
-    update: (activatorEl: HTMLElement | ComponentPublicInstance) => Promise<void>;
+    contentRef: vue.ShallowRef<MaybeElement, MaybeElement>;
+    update: () => Promise<void>;
 };
 
-declare function useToggle(value?: boolean): [ShallowRef<boolean>, (val?: boolean) => void];
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date;
+type Path<T> = T extends Primitive ? never : T extends readonly unknown[] ? never : T extends object ? {
+    [K in keyof T & string]: T[K] extends Primitive ? K : K | `${K}.${Path<T[K]>}`;
+}[keyof T & string] : never;
+type LoosePath<T> = Path<T> | (string & {});
+type IterableItemsProps<T> = {
+    items: readonly T[];
+    titleKey?: LoosePath<T>;
+    valueKey?: LoosePath<T>;
+};
+type NormalizedItem<T> = {
+    raw: T;
+    title: unknown;
+    value: unknown;
+    key: string;
+};
+declare function useNormalizedItems<T>(props: IterableItemsProps<T>): vue.ComputedRef<NormalizedItem<T>[]>;
 
-declare function useInputValue<T = any>(props: Record<string, any>): ComputedRef<string>;
+type SelectableProps<T> = {
+    modelValue: T | T[];
+    multiple?: boolean;
+    mandatory?: boolean;
+};
+type SelectableEventProps<T> = {
+    'onUpdate:modelValue'?: (value: T | T[] | undefined) => void;
+};
+type SelectablePublicProps<T> = SelectableProps<T> & SelectableEventProps<T>;
+declare function useSelectedChips<T>(props: IterableItemsProps<T> & SelectableProps<T>): {
+    hasValue: vue.ComputedRef<boolean>;
+    chips: vue.ComputedRef<any[]>;
+    select: (value: T) => void;
+};
+
+declare function useAutocomplete<T = any>(props: IterableItemsProps<T> & SelectableProps<T>): {
+    normalizedItems: vue.ComputedRef<NormalizedItem<T>[]>;
+    chips: vue.ComputedRef<any[]>;
+    searchItems: vue.ComputedRef<NormalizedItem<T>[]>;
+    hasValue: vue.ComputedRef<boolean>;
+    inputValue: vue.ShallowRef<any, any>;
+    select: (value: T) => void;
+};
+
+declare function useButtonPresets({ props }: {
+    props: CBtnProps;
+}): vue.ComputedRef<{
+    root: string[];
+    label: never[];
+}>;
+
+declare enum BreakpointLabels {
+    XS = "xs",
+    SM = "sm",
+    MD = "md",
+    LG = "lg",
+    XL = "xl",
+    XXL = "xxl"
+}
 
 declare enum IconAliases {
     DROPDOWN = "dropdown",
     CHECKBOX_ON = "checkboxOn",
     CHECKBOX_OFF = "checkboxOff",
-    CALENDAR = "calendar"
+    CALENDAR = "calendar",
+    CHEVRON_LEFT = "chevronLeft",
+    CHEVRON_RIGHT = "chevronRight",
+    RADIO_ON = "radioOn",
+    RADIO_OFF = "radioOff",
+    CLOSE = "close"
 }
 
 type IconsOptions = {
     dir?: string;
     aliases?: Partial<Record<IconAliases, any>>;
+    sets?: Record<string, any>;
 };
 interface LibOptions {
     components: Record<string, ComponentInstance<any> | FunctionalComponent>;
     directives?: Record<string, Directive>;
-    themes?: Record<string, any>;
+    themes?: ThemesOptions;
+    breakpoints?: Record<BreakpointLabels, number>;
     icons?: IconsOptions;
     presets?: Record<string, Record<string, any>>;
+    theme?: string;
     ssr?: boolean;
 }
 declare class VuelandUI {
-    themes: LibOptions['themes'];
+    themes: ThemesOptions;
     icons: IconsOptions;
     presets: Record<string, Record<string, any>>;
+    breakpoints: Record<BreakpointLabels, number>;
+    theme?: string;
     private installed;
+    applyTheme(name: string): void;
     install(app: App, options: LibOptions): void;
 }
 
 declare function useCore(): VuelandUI;
 
-declare function useOverlayStack(): {
-    register: () => number;
-    unregister: () => void;
+type DelayProps = {
+    openDelay?: number | string;
+    closeDelay?: number | string;
+};
+declare const makeDelayProps: {
+    <TDefaults extends Partial<Record<"openDelay" | "closeDelay", unknown>>>(defaults: TDefaults): {
+        openDelay: "openDelay" extends infer T ? T extends "openDelay" ? T extends keyof TDefaults ? {
+            openDelay: (StringConstructor | NumberConstructor)[];
+            closeDelay: (StringConstructor | NumberConstructor)[];
+        }[T] & {
+            default: TDefaults[T];
+        } : {
+            openDelay: (StringConstructor | NumberConstructor)[];
+            closeDelay: (StringConstructor | NumberConstructor)[];
+        }[T] : never : never;
+        closeDelay: "closeDelay" extends infer T_1 ? T_1 extends "closeDelay" ? T_1 extends keyof TDefaults ? {
+            openDelay: (StringConstructor | NumberConstructor)[];
+            closeDelay: (StringConstructor | NumberConstructor)[];
+        }[T_1] & {
+            default: TDefaults[T_1];
+        } : {
+            openDelay: (StringConstructor | NumberConstructor)[];
+            closeDelay: (StringConstructor | NumberConstructor)[];
+        }[T_1] : never : never;
+    };
+    (): {
+        openDelay: (StringConstructor | NumberConstructor)[];
+        closeDelay: (StringConstructor | NumberConstructor)[];
+    };
+};
+declare function useDelayedActions(props: Partial<DelayProps> & Record<string, any>): {
+    openDelay: (fn: (...args: any) => any) => void;
+    closeDelay: (fn: (...args: any) => any) => void;
 };
 
 type DialogStackItem = {
@@ -309,7 +761,7 @@ type DialogStackItem = {
     component: any;
     props?: Record<string, any>;
 };
-interface DialogsStackApi {
+interface DialogsStackAPI {
     stack: ShallowRef<DialogStackItem[]>;
     current: ComputedRef<DialogStackItem | undefined>;
     openDialog: (options: {
@@ -319,8 +771,68 @@ interface DialogsStackApi {
     closeDialog: (id?: number) => void;
     closeAll: () => void;
 }
-declare function createDialogsStack(): DialogsStackApi;
-declare function useDialogsStack(): DialogsStackApi;
+declare function createDialogsStack(): DialogsStackAPI;
+declare function useDialogsStack(): DialogsStackAPI;
+
+declare const breakpoints: {
+    readonly xs: 0;
+    readonly sm: 600;
+    readonly md: 960;
+    readonly lg: 1280;
+    readonly xl: 1920;
+    readonly xxl: 2560;
+};
+interface AppBreakpoints {
+    xxl: MaybeRef<boolean>;
+    xl: MaybeRef<boolean>;
+    lg: MaybeRef<boolean>;
+    md: MaybeRef<boolean>;
+    sm: MaybeRef<boolean>;
+    xs: MaybeRef<boolean>;
+    xlAndLess: MaybeRef<boolean>;
+    lgAndLess: MaybeRef<boolean>;
+    mdAndLess: MaybeRef<boolean>;
+    smAndLess: MaybeRef<boolean>;
+    xlAndUp: MaybeRef<boolean>;
+    lgAndUp: MaybeRef<boolean>;
+    mdAndUp: MaybeRef<boolean>;
+    smAndUp: MaybeRef<boolean>;
+}
+declare function useDisplay(): {
+    state: {
+        xxl: boolean;
+        xl: boolean;
+        lg: boolean;
+        md: boolean;
+        sm: boolean;
+        xs: boolean;
+        xlAndLess: boolean;
+        lgAndLess: boolean;
+        mdAndLess: boolean;
+        smAndLess: boolean;
+        xlAndUp: boolean;
+        lgAndUp: boolean;
+        mdAndUp: boolean;
+        smAndUp: boolean;
+    };
+    createDisplay: (points?: Record<BreakpointLabels, number>) => {
+        update: () => void;
+        xxl: vue.Ref<boolean, boolean>;
+        xl: vue.Ref<boolean, boolean>;
+        lg: vue.Ref<boolean, boolean>;
+        md: vue.Ref<boolean, boolean>;
+        sm: vue.Ref<boolean, boolean>;
+        xs: vue.Ref<boolean, boolean>;
+        xlAndLess: vue.Ref<boolean, boolean>;
+        lgAndLess: vue.Ref<boolean, boolean>;
+        mdAndLess: vue.Ref<boolean, boolean>;
+        smAndLess: vue.Ref<boolean, boolean>;
+        xlAndUp: vue.Ref<boolean, boolean>;
+        lgAndUp: vue.Ref<boolean, boolean>;
+        mdAndUp: vue.Ref<boolean, boolean>;
+        smAndUp: vue.Ref<boolean, boolean>;
+    };
+};
 
 /**
  * @description - кастомный эффект, для кейсов где понадобится
@@ -333,47 +845,150 @@ declare const useEffect: <T = any>(fn: () => any, scheduler?: (newVal?: any, old
     readonly __v_isRef: boolean;
 };
 
-declare function useForm(): FormApi | null;
+declare function useForm(): FormAPI | null;
+
+type IconMode = 'sprite' | 'component' | 'raw' | 'fa' | 'md';
+interface UseIconOptions {
+    name?: string | number;
+    source?: IconMode;
+    component?: Component | null;
+    body?: string;
+    viewBox?: string;
+    spritePrefix?: string;
+    spritePath?: string;
+}
+interface SvgIconData {
+    body: string;
+    viewBox?: string;
+    size?: number;
+}
+interface FontIconData {
+    text: string;
+    className: string;
+}
+interface ComponentIconData {
+    component: Component;
+}
+interface SpriteIconData {
+    href: string;
+    viewBox?: string;
+}
+type IconResolverResult = ({
+    kind: 'svg';
+} & SvgIconData) | ({
+    kind: 'font';
+} & FontIconData) | ({
+    kind: 'component';
+} & ComponentIconData) | ({
+    kind: 'sprite';
+} & SpriteIconData) | null | undefined;
+type IconResolver = (name: string | number, options: UseIconOptions) => IconResolverResult;
+interface ResolvedIcon {
+    kind: 'svg' | 'component' | 'sprite' | 'font';
+    component: Component | null;
+    body: string;
+    viewBox: string;
+    href: string;
+    text: string;
+    className: string;
+    size?: number;
+    found: boolean;
+}
+declare function useIcon(props: UseIconOptions): ComputedRef<ResolvedIcon>;
 
-type PresetProps = {
-    preset?: string;
+type IdOptions = {
+    prefix?: string;
+    postfix?: string;
+};
+declare function useId(id?: string | number, { prefix, postfix }?: IdOptions): string;
+
+type ValidateResult = {
+    valid: boolean;
+    message: string;
+};
+type ValidateFn = (value: any) => ValidateResult | Promise<ValidateResult>;
+type ValidateOn = 'input' | 'blur';
+type ValidateProps = {
+    rules?: ValidateFn[];
+    validateOn?: ValidateOn;
+};
+type ValidateState = {
+    errorMessage: Maybe<string>;
+    hasError: boolean;
+    validating: boolean;
+};
+declare enum InputEvents {
+    INPUT = "input",
+    BLUR = "blur"
+}
+declare function useValidate(props: ValidateProps & {
+    modelValue: any;
+    readonly?: boolean;
+    disabled?: boolean;
+}, state: Reactive<InputState>): {
+    errors: vue.ShallowReactive<ValidateState>;
+    hasRules: vue.ComputedRef<boolean>;
+    resetValidate: () => void;
+    validate: () => Promise<boolean>;
 };
-declare function usePresets<T>(props: PresetProps): ComputedRef<Maybe<T>>;
 
-declare function useInputPresets({ props, errors }: {
+declare function useInputPresets({ props, errors, state, }: {
     props: CInputProps;
-    errors: ShallowReactive<any>;
-    state: ShallowReactive<any>;
+    errors: ValidateState;
+    state: InputState;
 }): vue.ComputedRef<{
     root: string[];
-    label: string[];
-    field: string[];
+    field: string | undefined;
     details: string[];
 }>;
 
+type KeyboardKey = 'Enter' | 'Escape' | 'Backspace' | 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'Tab' | 'Home' | 'End' | 'Space';
+type KeyboardHandler = (event: KeyboardEvent) => void;
+type KeyboardHandlers = Partial<Record<KeyboardKey, KeyboardHandler>>;
+type UseKeyboardOptions = {
+    prevent?: boolean | KeyboardKey[];
+    stop?: boolean | KeyboardKey[];
+};
+declare function useKeyboard(handlers: KeyboardHandlers, options?: UseKeyboardOptions): {
+    onKeydown: (event: KeyboardEvent) => void;
+};
+
+declare function useMenu(): any;
+
 declare function useMenuPresets({ props }: {
     props: CMenuProps;
 }): vue.ComputedRef<{
     root: string[];
 }>;
 
-declare function useButtonPresets({ props }: {
-    props: CBtnProps;
-}): vue.ComputedRef<{
-    root: string[];
-    label: string[];
-}>;
+declare function clearOverlayStack(): void;
+declare function useOverlayStack(): {
+    register: () => number;
+    unregister: () => void;
+};
 
-declare function useAppScroll(): {
-    appRef: vue.ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
-    classes: vue.ComputedRef<{
-        'c-app--block-scroll': boolean;
-    }>;
-    getScrollTop: () => number;
-    getScrollLeft: () => number;
-    blockScroll: () => void;
-    unblockScroll: () => void;
+type PresetProps = {
+    preset?: string;
 };
+declare const makePresetProps: {
+    <TDefaults extends Partial<Record<"preset", unknown>>>(defaults: TDefaults): {
+        preset: "preset" extends infer T ? T extends "preset" ? T extends keyof TDefaults ? {
+            preset: StringConstructor;
+        }[T] & {
+            default: TDefaults[T];
+        } : {
+            preset: StringConstructor;
+        }[T] : never : never;
+    };
+    (): {
+        preset: StringConstructor;
+    };
+};
+declare function usePresets<T>(props: PresetProps): ComputedRef<Maybe<T>>;
+
+declare function useSelectControl(): any;
+
+declare function useToggle(value?: boolean): [ShallowRef<boolean>, () => void];
 
-export { InputEvents, breakpoints, createDialogsStack, useActivator, useAppScroll, useApplication, useAutoPosition, useAutocomplete, useButtonPresets, useCore, useDelayedActions, useDialogsStack, useDisplay, useEffect, useFieldAttrs, useForm, useInputPresets, useInputState, useInputValue, useMenuPresets, useOverlayStack, usePositionClasses, usePresets, useToggle, useValidate };
-export type { ActivatorListeners, ActivatorProps, AppBreakpoints, AutoPositionProps, CoordsProps, DelayProps, DialogStackItem, DialogsStackApi, Dimensions, InputState, InputStateProps, PositionProps, PresetProps, ValidateFn, ValidateOn, ValidateProps, ValidateState };
+export { InputEvents, breakpoints, clearOverlayStack, createDialogsStack, makeActivatorProps, makeAutoPositionProps, makeDelayProps, makePresetProps, useActivator, useAppScroll, useApplication, useAutoPosition, useAutocomplete, useButtonPresets, useCore, useDelayedActions, useDialogsStack, useDisplay, useEffect, useForm, useIcon, useId, useInputPresets, useKeyboard, useMenu, useMenuPresets, useNormalizedItems, useOverlayStack, usePresets, useSelectControl, useSelectedChips, useToggle, useValidate };
+export type { ActivatorListeners, ActivatorProps, AppBreakpoints, AutoPositionProps, ComponentIconData, DelayProps, DialogStackItem, DialogsStackAPI, Dimensions, FontIconData, IconMode, IconResolver, IconResolverResult, IdOptions, IterableItemsProps, KeyboardHandler, KeyboardHandlers, KeyboardKey, LoosePath, NormalizedItem, Path, PresetProps, Primitive, ResolvedIcon, SelectableEventProps, SelectableProps, SelectablePublicProps, SpriteIconData, SvgIconData, UseIconOptions, UseKeyboardOptions, ValidateFn, ValidateOn, ValidateProps, ValidateResult, ValidateState };