@central-design-system/components 3.0.0-alpha.0 → 3.0.0-alpha.1

package/dist/composable/items.d.ts

@@ -1,5 +1,5 @@
-import { SelectItemKey } from '../utils';
 import type { PropType, ComputedRef } from 'vue';
+export declare type TItemKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);
 export interface IInternalItem<T = any> {
     title: string;
     value: any;
@@ -13,14 +13,15 @@ export interface IInternalItem<T = any> {
 }
 export interface IItemsProps {
     items: any[];
-    itemTitle: SelectItemKey;
-    itemValue: SelectItemKey;
-    itemChildren: SelectItemKey;
-    itemProps: SelectItemKey;
+    itemTitle: TItemKey;
+    itemValue: TItemKey;
+    itemChildren: TItemKey;
+    itemProps: TItemKey;
     returnObject: boolean;
 }
 export interface IUseItems {
     items: ComputedRef<IInternalItem[]>;
+    itemsProps: string[];
 }
 export declare const makeItemsProps: <Defaults extends {
     items?: unknown;
@@ -41,28 +42,28 @@ export declare const makeItemsProps: <Defaults extends {
      * Ключ для заголовка элемента
      */
     itemTitle: {
-        type: PropType<SelectItemKey>;
+        type: PropType<TItemKey>;
         default: string;
     };
     /**
      * Ключ для значения элемента
      */
     itemValue: {
-        type: PropType<SelectItemKey>;
+        type: PropType<TItemKey>;
         default: string;
     };
     /**
      * Ключ для дочерних элементов
      */
     itemChildren: {
-        type: PropType<SelectItemKey>;
+        type: PropType<TItemKey>;
         default: string;
     };
     /**
      * Ключ для дополнительных свойств элемента
      */
     itemProps: {
-        type: PropType<SelectItemKey>;
+        type: PropType<TItemKey>;
         default: string;
     };
     /**

package/dist/composable/lazy.d.ts

@@ -0,0 +1,11 @@
+import { ComputedRef } from 'vue';
+import type { Ref } from 'vue';
+export interface ILazyProps {
+    eager: boolean;
+}
+export interface IUseLazy {
+    isBooted: Ref<boolean>;
+    hasContent: ComputedRef<boolean>;
+    onAfterLeave: () => void;
+}
+export declare function useLazy(props: ILazyProps, active: Ref<boolean>): IUseLazy;

package/dist/composable/link.d.ts

@@ -1,4 +1,3 @@
-import { SetupContext } from 'vue';
 import type { ComputedRef, PropType } from 'vue';
 import type { RouteLocationRaw, useLink as TUseLink } from 'vue-router';
 export interface ILinkProps {
@@ -33,4 +32,4 @@ export declare const makeLinkProps: <Defaults extends {
         default: undefined;
     };
 }, Defaults>;
-export declare function useLink(props: ILinkProps, context: SetupContext<any>): IUseLink;
+export declare function useLink(props: ILinkProps, emit: Function): IUseLink;

package/dist/composable/loading.d.ts

@@ -4,6 +4,7 @@ export interface ILoadingProp {
 }
 export interface IUseLoading {
     loadingClasses: ComputedRef<string | undefined>;
+    hasLoading: ComputedRef<boolean>;
 }
 export declare const makeLoadingProps: <Defaults extends {
     loading?: unknown;

package/dist/composable/nested/nested.d.ts

@@ -26,7 +26,7 @@ export interface INestedProps {
     'onUpdate:selected'?: ((val: unknown[]) => void) | undefined;
     'onUpdate:opened'?: ((val: unknown[]) => void) | undefined;
 }
-export declare const VNestedSymbol: InjectionKey<TNestedProvide>;
+export declare const NestedKey: InjectionKey<TNestedProvide>;
 export declare const emptyNested: TNestedProvide;
 export declare const makeNestedProps: <Defaults extends {
     selectStrategy?: unknown;
@@ -56,7 +56,7 @@ export declare const makeNestedProps: <Defaults extends {
      */
     required: BooleanConstructor;
 }, Defaults>;
-export declare const useNested: (props: INestedProps, ctx: SetupContext<any>) => TNestedProvide['root'];
+export declare const useNested: (props: INestedProps, ctx: SetupContext<any[]>) => TNestedProvide['root'];
 export declare const useNestedItem: (id: Ref<unknown>, isGroup: boolean) => {
     id: import("vue").ComputedRef<{}>;
     open: (open: boolean, event: Event) => void;

package/dist/composable/overlay.d.ts

@@ -0,0 +1,99 @@
+import { PropType } from 'vue';
+export interface IOverlayProps {
+    attach: boolean | string | Element | undefined;
+    contained: boolean | undefined;
+    eager: boolean | undefined;
+    disabled: boolean | undefined;
+    persistent: boolean | undefined;
+    scrim: boolean | string | undefined;
+    modelValue: boolean | undefined;
+    zIndex: number | string | undefined;
+    contentClasses: string | string[] | Record<string, boolean> | undefined;
+    contentProps: Record<string, unknown> | undefined;
+}
+export declare const makeOverlayProps: <Defaults extends {
+    attach?: unknown;
+    contained?: unknown;
+    eager?: unknown;
+    disabled?: unknown;
+    persistent?: unknown;
+    scrim?: unknown;
+    modelValue?: unknown;
+    zIndex?: unknown;
+    contentClasses?: unknown;
+    contentProps?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Указывает, к какому DOM элементу будет прикреплен компонент.
+     * По умолчанию прикрепляется к body.
+     * Если передана строка, то ищет элемент по querySelector.
+     * Если передан объект, то считает его допустимым Node элементом.
+     */
+    attach: {
+        type: PropType<string | boolean | Element>;
+        default: boolean;
+    };
+    /**
+     * Указывает, что компонент будет прикреплен к родительскому элементу. Подразумевает absolute и attach
+     */
+    contained: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Принудительно рендерит контент компонента в DOM, даже если компонент скрыт. Полезно для SEO оптимизации.
+     */
+    eager: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Блокирует возможность клика или фокуса всплывающего компонента
+     */
+    disabled: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Клик за пределами компонента или esc не будет закрывать его
+     */
+    persistent: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Фон для компонента. Строкой можно передать цвет фона.
+     */
+    scrim: {
+        type: PropType<string | boolean>;
+        default: boolean;
+    };
+    /**
+     * Значение v-model. Управляет видимостью компонента.
+     */
+    modelValue: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Значение z-index для оверлея
+     */
+    zIndex: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    /**
+     * Классы для контента компонента
+     */
+    contentClasses: {
+        type: PropType<string | string[] | Record<string, boolean>>;
+        default: null;
+    };
+    /**
+     * Свойства для контента компонента
+     */
+    contentProps: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+}, Defaults>;

package/dist/composable/scopeId.d.ts

@@ -0,0 +1,5 @@
+export declare function useScopeId(): {
+    scopeId: {
+        [x: string]: string;
+    };
+};

package/dist/composable/transition.d.ts

@@ -0,0 +1,22 @@
+import type { Component, FunctionalComponent, PropType, TransitionProps } from 'vue';
+interface ITransitionProps extends TransitionProps {
+    transition: string | boolean | (TransitionProps & {
+        component?: Component;
+    });
+}
+export declare const makeTransitionProps: <Defaults extends {
+    transition?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Анимация компонента
+     */
+    transition: {
+        type: PropType<string | boolean | (TransitionProps & {
+            component?: Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
+        })>;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+}, Defaults>;
+export declare const CdsTransition: FunctionalComponent<ITransitionProps>;
+export {};

package/dist/composable/validation.d.ts

@@ -0,0 +1,136 @@
+import type { PropType, ComputedRef, Ref } from 'vue';
+import type { MaybeRef } from '../utils';
+export declare type TValidationResult = string | boolean;
+export declare type TValidationRule = TValidationResult | PromiseLike<TValidationResult> | ((value: any) => TValidationResult) | ((value: any) => PromiseLike<TValidationResult>);
+export declare type TValidationOn = typeof allowedValidationOn[number];
+export interface IValidationProps {
+    disabled: boolean;
+    error: boolean;
+    errorMessages: string | string[];
+    focused: boolean;
+    maxErrors: string | number;
+    name: string | undefined;
+    label: string | undefined;
+    readonly: boolean;
+    rules: TValidationRule[];
+    modelValue: any;
+    validateOn?: TValidationOn;
+    validationValue: any;
+    hideMessages: boolean;
+}
+export interface IUseValidation {
+    errorMessages: ComputedRef<string[]>;
+    isDisabled: ComputedRef<boolean>;
+    isReadonly: ComputedRef<boolean>;
+    isDirty: ComputedRef<boolean>;
+    isPure: Ref<boolean>;
+    isValid: ComputedRef<boolean | null>;
+    isValidating: Ref<boolean>;
+    validate: () => Promise<string[]>;
+    reset: () => void;
+    resetValidation: () => void;
+    validationClasses: ComputedRef<Record<string, boolean>>;
+}
+export declare const allowedValidationOn: readonly ["blur", "input", "submit"];
+export declare const makeValidationProps: <Defaults extends {
+    disabled?: unknown;
+    error?: unknown;
+    errorMessages?: unknown;
+    maxErrors?: unknown;
+    name?: unknown;
+    label?: unknown;
+    readonly?: unknown;
+    rules?: unknown;
+    modelValue?: unknown;
+    validateOn?: unknown;
+    validationValue?: unknown;
+    hideMessages?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Заблокированное состояние
+     */
+    disabled: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Состояние ошибки
+     */
+    error: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Сообщения об ошибках
+     */
+    errorMessages: {
+        type: PropType<string | string[]>;
+        default: () => never[];
+    };
+    /**
+     * Максимально количество выводимых ошибок
+     */
+    maxErrors: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    /**
+     * Имя поля
+     */
+    name: {
+        type: PropType<string | undefined>;
+        default: undefined;
+    };
+    /**
+     * Лейбл поля
+     */
+    label: {
+        type: PropType<string | undefined>;
+        default: undefined;
+    };
+    /**
+     * Только для чтения
+     */
+    readonly: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Правила валидации
+     */
+    rules: {
+        type: PropType<TValidationRule[]>;
+        default: () => never[];
+    };
+    /**
+     * Значение модели
+     */
+    modelValue: {
+        type: PropType<any>;
+        default: null;
+    };
+    /**
+     * Событие для валидации
+     */
+    validateOn: {
+        type: PropType<"input" | "blur" | "submit">;
+        default: string;
+        available: readonly ["blur", "input", "submit"];
+        validator: (value: TValidationOn) => boolean;
+    };
+    /**
+     * Значение для валидации
+     */
+    validationValue: {
+        type: PropType<any>;
+        default: undefined;
+    };
+    /**
+     * Убирает слот для сообщений об ошибках, если ошибок нет
+     */
+    hideMessages: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}, Defaults>;
+export declare function useValidation(props: IValidationProps, name: string, id?: MaybeRef<string | number>): IUseValidation;

package/dist/directives/click-outside/index.d.ts

@@ -0,0 +1,14 @@
+import type { DirectiveBinding } from 'vue';
+interface IClickOutsideBindingArgs {
+    handler: (event: MouseEvent) => void;
+    closeConditional?: (event: Event) => boolean;
+    include?: () => HTMLElement[];
+}
+interface IClickOutsideDirectiveBinding extends DirectiveBinding {
+    value: ((event: MouseEvent) => void) | IClickOutsideBindingArgs;
+}
+export declare const ClickOutside: {
+    mounted(el: HTMLElement, binding: IClickOutsideDirectiveBinding): void;
+    unmounted(el: HTMLElement, binding: IClickOutsideDirectiveBinding): void;
+};
+export default ClickOutside;

package/dist/directives/index.d.ts

@@ -1,2 +1 @@
-declare const _default: {};
-export default _default;
+export { ClickOutside } from './click-outside';

package/dist/globals.d.ts

@@ -0,0 +1,16 @@
+declare global {
+  interface HTMLCollection {
+    [Symbol.iterator](): IterableIterator<Element>;
+  }
+
+  interface HTMLElement {
+    _clickOutside?: Record<
+      number,
+      | {
+          onClick: EventListener;
+          onMousedown: EventListener;
+        }
+      | undefined
+    > & { lastMousedownWasOutside: boolean };
+  }
+}

package/dist/transitions/createTransition.d.ts

@@ -1,5 +1,34 @@
-import type { Prop } from 'vue';
-export declare function createCssTransition(): void;
+import type { PropType, Prop } from 'vue';
+export declare function createCssTransition(name: string, origin?: string, mode?: string): import("vue").DefineComponent<{
+    group: PropType<boolean>;
+    hideOnLeave: PropType<boolean>;
+    leaveAbsolute: PropType<boolean>;
+    mode: {
+        type: PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: PropType<boolean>;
+    hideOnLeave: PropType<boolean>;
+    leaveAbsolute: PropType<boolean>;
+    mode: {
+        type: PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: PropType<string>;
+        default: string;
+    };
+}>>, {
+    mode: string;
+    origin: string;
+}>;
 export declare function createJSTransition(name: string, functions: Record<string, any>, mode?: string): import("vue").DefineComponent<{
     mode: Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
 }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

package/dist/transitions/index.d.ts

@@ -12,3 +12,93 @@ export declare const CdsTransitionExpandX: import("vue").DefineComponent<{
 }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     mode: import("vue").Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
 }>>, {}>;
+export declare const CdsTransitionFade: import("vue").DefineComponent<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}>>, {
+    mode: string;
+    origin: string;
+}>;
+export declare const CdsTransitionSlideY: import("vue").DefineComponent<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}>>, {
+    mode: string;
+    origin: string;
+}>;
+export declare const CdsTransitionSlideX: import("vue").DefineComponent<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}>>, {
+    mode: string;
+    origin: string;
+}>;

package/dist/utils/anchor.d.ts

@@ -0,0 +1,23 @@
+declare const block: readonly ["top", "bottom"];
+declare const inline: readonly ["start", "end", "left", "right"];
+declare type Tblock = typeof block[number];
+declare type Tinline = typeof inline[number];
+export declare type TAnchor = Tblock | Tinline | 'center' | 'center center' | `${Tblock} ${Tinline | 'center'}` | `${Tinline} ${Tblock | 'center'}`;
+export declare type ParsedAnchor = {
+    side: 'center';
+    align: 'center';
+} | {
+    side: Tblock;
+    align: 'left' | 'right' | 'center';
+} | {
+    side: 'left' | 'right';
+    align: Tblock | 'center';
+};
+/** Parse a raw anchor string into an object */
+export declare function parseAnchor(anchor: TAnchor): ParsedAnchor;
+export declare function toPhysical(str: 'center' | Tblock | Tinline): "right" | "top" | "bottom" | "left" | "center";
+export declare function flipSide(anchor: ParsedAnchor): ParsedAnchor;
+export declare function flipAlign(anchor: ParsedAnchor): ParsedAnchor;
+export declare function flipCorner(anchor: ParsedAnchor): ParsedAnchor;
+export declare function getAxis(anchor: ParsedAnchor): "y" | "x";
+export {};

package/dist/utils/animation.d.ts

@@ -0,0 +1,6 @@
+import { Box } from './box';
+/** @see https://stackoverflow.com/a/57876601/2074736 */
+export declare function nullifyTransforms(el: HTMLElement): Box;
+export declare function animate(el: Element, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation | {
+    finished: Promise<void>;
+};

package/dist/utils/box.d.ts

@@ -0,0 +1,26 @@
+export declare class Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor({ x, y, width, height }: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    });
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+}
+export declare function getOverflow(a: Box, b: Box): {
+    x: {
+        before: number;
+        after: number;
+    };
+    y: {
+        before: number;
+        after: number;
+    };
+};

package/dist/utils/dom.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns:
+ *  - 'null' if the node is not attached to the DOM
+ *  - the root node (HTMLDocument | ShadowRoot) otherwise
+ */
+export declare function attachedRoot(node: Node): null | HTMLDocument | ShadowRoot;

package/dist/utils/getScrollParent.d.ts

@@ -0,0 +1,3 @@
+export declare function getScrollParent(el?: HTMLElement): HTMLElement;
+export declare function getScrollParents(el?: Element | null, stopAt?: Element | null): HTMLElement[];
+export declare function hasScrollbar(el?: Element | null): boolean;

package/dist/utils/globals.d.ts

@@ -0,0 +1,4 @@
+export declare const IN_BROWSER: boolean;
+export declare const SUPPORTS_INTERSECTION: boolean;
+export declare const SUPPORTS_TOUCH: boolean;
+export declare const SUPPORTS_FOCUS_VISIBLE: boolean;

package/dist/utils/helpers.d.ts

@@ -1,4 +1,5 @@
-import type { Ref } from 'vue';
+import type { ComponentPublicInstance, ComputedGetter, PropType, Ref, ToRefs } from 'vue';
+import type { TItemKey } from '../composable';
 export declare const keyCodes: Readonly<{
     enter: 13;
     tab: 9;
@@ -32,6 +33,11 @@ export declare const classesStates: Readonly<{
 }>;
 export declare function isObject(obj: any): obj is object;
 export declare function mergeDeep(source?: Record<string, any>, target?: Record<string, any>, arrayFn?: (a: unknown[], b: unknown[]) => unknown[]): Record<string, any>;
+/**
+ * Wrap value in array if it's not already an array
+ * @param value
+ */
+export declare function wrapInArray<T>(value: T | T[] | null | undefined): T[];
 export declare function getNestedValue(obj: any, path: (string | number)[], fallback?: any): any;
 export declare function getObjectValueByPath(obj: any, path: string, fallback?: any): any;
 export declare function getPropertyFromItem(item: any, property: SelectItemKey, fallback?: any): any;
@@ -41,9 +47,27 @@ export declare function getPropertyFromItem(item: any, property: SelectItemKey,
  * @param paths
  */
 export declare function pick<T extends object, U extends Extract<keyof T, string>>(obj: T, paths: U[]): [yes: MaybePick<T, U>, no: Omit<T, U>];
+/**
+ * Convert a computed ref to a record of refs.
+ * The getter function must always return an object with the same keys.
+ */
+export declare function destructComputed<T extends object>(getter: ComputedGetter<T & NotAUnion<T>>): ToRefs<T>;
+/** Array.includes but value can be any type */
+export declare function includes(arr: readonly any[], val: any): boolean;
+export declare function convertToUnit(str: number, unit?: string): string;
+export declare function convertToUnit(str: string | number | null | undefined, unit?: string): string | undefined;
+export declare function clamp(value: number, min?: number, max?: number): number;
+export declare const isOn: (key: string) => boolean;
+export declare const EventProp: PropType<(...args: any[]) => any>;
+export declare function isComponentInstance(obj: any): obj is ComponentPublicInstance;
+export declare function isFixedPosition(el?: HTMLElement): boolean;
 /**
  * Types
  */
 export declare type MaybeRef<T> = T | Ref<T>;
-export declare type SelectItemKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);
+export declare type SelectItemKey = TItemKey;
 export declare type MaybePick<T extends object, U extends Extract<keyof T, string>> = Record<string, unknown> extends T ? Partial<Pick<T, U>> : Pick<T, U>;
+export declare type EventProp<T = (...args: any[]) => any> = T;
+declare type NotAUnion<T> = [T] extends [infer U] ? _NotAUnion<U, U> : never;
+declare type _NotAUnion<T, U> = U extends any ? ([T] extends [U] ? unknown : never) : never;
+export {};