@vueland/ui 0.0.1 → 0.0.3

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, ComputedRef, Ref, ShallowReactive, App, ComponentInstance, FunctionalComponent, Directive, ShallowRef, 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;
@@ -183,8 +22,8 @@ type ActivatorListeners = {
     change?: (e: Event) => void;
 };
 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,51 +34,195 @@ 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;
+type ApplicationApi = {
+    blockScroll(): void;
+    unblockScroll(): void;
+    getScrollTop(): number;
+    getScrollLeft(): number;
 };
 
-type Classes = 'to--left' | 'to--right' | 'to--top' | 'to--bottom';
-interface PositionProps {
-    left?: boolean;
-    right?: boolean;
-    top?: boolean;
-    bottom?: boolean;
+interface InputState {
+    focused: boolean;
+    isDirty: boolean;
 }
-declare function usePositionClasses(props: PositionProps): vue.ComputedRef<Record<Classes, boolean>>;
+type CInputRole = 'combobox' | 'checkbox' | 'radio' | '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;
+    role?: CInputRole;
+};
 
-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 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;
 
 declare function useApplication(): ApplicationApi;
 
+declare function useApplicationScroll(): {
+    appRef: vue.ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
+    classes: vue.ComputedRef<{
+        'c-app--block-scroll': boolean;
+    }>;
+    getScrollTop: () => number;
+    getScrollLeft: () => number;
+    blockScroll: () => void;
+    unblockScroll: () => void;
+};
+
+type AriaHaspopup = 'true' | 'false' | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog';
+
+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",
+    CHEVRON_LEFT = "chevronLeft",
+    CHEVRON_RIGHT = "chevronRight",
+    RADIO_ON = "radioOn",
+    RADIO_OFF = "radioOff",
+    CLOSE = "close"
+}
+
+interface AriaActivatorState {
+    expanded: boolean;
+    haspopup?: AriaHaspopup | boolean;
+    controls?: string;
+}
+declare function useAriaActivator(state: () => AriaActivatorState): vue.ComputedRef<Partial<Record<string, string>>>;
+
+interface AriaDialogState {
+    labelledBy?: string;
+    describedBy?: string;
+    modal?: boolean;
+}
+declare function useAriaDialog(state?: () => AriaDialogState): vue.ComputedRef<{
+    [x: string]: string | undefined;
+}>;
+
+interface AriaFieldState {
+    fieldId: string;
+    label?: string | boolean;
+    hasDetails?: boolean;
+    hasError?: boolean;
+    errorMessage?: string;
+    readonly?: boolean;
+    disabled?: boolean;
+}
+declare function useAriaField(state: () => AriaFieldState): vue.ComputedRef<{
+    [x: string]: string | undefined;
+}>;
+
+interface AriaListboxState {
+    multiple?: boolean;
+    activeDescendant?: string;
+}
+declare function useAriaListbox(state: () => AriaListboxState): vue.ComputedRef<{
+    [x: string]: string | undefined;
+}>;
+
+type AriaToggleMode = 'checkbox' | 'switch' | 'button';
+interface AriaToggleState {
+    checked?: boolean | 'mixed';
+    mode?: AriaToggleMode;
+    disabled?: boolean;
+    required?: boolean;
+}
+declare function useAriaToggle(state: () => AriaToggleState): vue.ComputedRef<{
+    [x: string]: string | undefined;
+}>;
+
 interface Dimensions {
     top: number;
     left: number;
     width: number;
     height: number;
 }
-interface CoordsProps {
+type AlignSide = 'top' | 'bottom' | 'left' | 'right';
+type AlignValue = AlignSide | 'top-center' | 'top-left' | 'top-right' | 'bottom-center' | 'bottom-left' | 'bottom-right' | 'left-center' | 'right-center';
+interface AutoPositionProps {
+    strategy?: 'reverse' | 'bounce';
     positionX?: number;
     positionY?: number;
     offsetX?: number | string;
     offsetY?: number | string;
+    align?: AlignValue;
 }
-interface AutoPositionProps {
-    strategy?: 'reverse' | 'bounce';
-}
-declare function useAutoPosition(props: PositionProps & CoordsProps & DimensionsProps & AutoPositionProps): {
+type MaybeElement = Element | ComponentPublicInstance | undefined;
+type AutoPositionInputProps = DimensionsProps & AutoPositionProps;
+declare function useAutoPosition(props: AutoPositionInputProps, activatorEl?: ComputedRef<MaybeElement>): {
     activator: vue.Ref<{
         top: number;
         left: number;
@@ -262,46 +245,129 @@ 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 enum IconAliases {
-    DROPDOWN = "dropdown",
-    CHECKBOX_ON = "checkboxOn",
-    CHECKBOX_OFF = "checkboxOff",
-    CALENDAR = "calendar"
+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 const breakpoints: {
+    readonly xs: 0;
+    readonly sm: 600;
+    readonly md: 960;
+    readonly lg: 1280;
+    readonly xl: 1920;
+    readonly xxl: 2560;
+};
+interface Breakpoints {
+    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;
 }
+type Display = {
+    [k in keyof Breakpoints]: Ref<boolean>;
+};
+declare function useDisplay(): {
+    state: ShallowReactive<Breakpoints>;
+    createDisplay(points?: Record<BreakpointLabels, number>): Display;
+    update(): void;
+};
+
+declare function useBreakpoints(): Display | undefined;
+
+declare function useButtonPresets({ props }: {
+    props: CBtnProps;
+}): vue.ComputedRef<{
+    root: string[];
+    label: never[];
+}>;
 
 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 function useDelayedActions(props: Partial<DelayProps> & Record<string, any>): {
+    openDelay: (fn: (...args: any) => any) => void;
+    closeDelay: (fn: (...args: any) => any) => void;
 };
 
 type DialogStackItem = {
@@ -309,7 +375,7 @@ type DialogStackItem = {
     component: any;
     props?: Record<string, any>;
 };
-interface DialogsStackApi {
+interface DialogsStackAPI {
     stack: ShallowRef<DialogStackItem[]>;
     current: ComputedRef<DialogStackItem | undefined>;
     openDialog: (options: {
@@ -319,8 +385,8 @@ interface DialogsStackApi {
     closeDialog: (id?: number) => void;
     closeAll: () => void;
 }
-declare function createDialogsStack(): DialogsStackApi;
-declare function useDialogsStack(): DialogsStackApi;
+declare function createDialogsStack(): DialogsStackAPI;
+declare function useDialogsStack(): DialogsStackAPI;
 
 /**
  * @description - кастомный эффект, для кейсов где понадобится
@@ -333,47 +399,130 @@ 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 IdOptions = {
+    prefix?: string;
+    postfix?: string;
+};
+declare function useId(id?: string | number, { prefix, postfix }?: IdOptions): string;
 
-type PresetProps = {
-    preset?: 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[];
 }>;
 
-declare function useMenuPresets({ props }: {
-    props: CMenuProps;
-}): vue.ComputedRef<{
-    root: 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 useButtonPresets({ props }: {
-    props: CBtnProps;
-}): vue.ComputedRef<{
-    root: string[];
-    label: string[];
-}>;
+declare function useMenu(): any;
 
-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;
+declare function clearOverlayStack(): void;
+declare function useOverlayStack(): {
+    register: () => number;
+    unregister: () => void;
+};
+
+type PresetProps = {
+    preset?: string;
 };
+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, useActivator, useApplication, useApplicationScroll, useAriaActivator, useAriaDialog, useAriaField, useAriaListbox, useAriaToggle, useAutoPosition, useAutocomplete, useBreakpoints, useButtonPresets, useCore, useDelayedActions, useDialogsStack, useDisplay, useEffect, useForm, useIcon, useId, useInputPresets, useKeyboard, useMenu, useNormalizedItems, useOverlayStack, usePresets, useSelectControl, useSelectedChips, useToggle, useValidate };
+export type { ActivatorListeners, ActivatorProps, AlignSide, AlignValue, AriaActivatorState, AriaDialogState, AriaFieldState, AriaListboxState, AriaToggleMode, AriaToggleState, AutoPositionProps, Breakpoints, ComponentIconData, DelayProps, DialogStackItem, DialogsStackAPI, Dimensions, Display, 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 };