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

package/dist/composable/refs.d.ts

@@ -0,0 +1,6 @@
+import type { Ref } from 'vue';
+export interface IUseRefs<T extends {}> {
+    refs: Ref<(T | undefined)[]>;
+    updateRef: (value: any, index: number) => void;
+}
+export declare function useRefs<T extends {}>(): IUseRefs<T>;

package/dist/composable/resizeObserver.d.ts

@@ -0,0 +1,7 @@
+import type { DeepReadonly, Ref } from 'vue';
+interface IUseResizeObserver {
+    resizeRef: Ref<HTMLElement | undefined>;
+    contentRect: DeepReadonly<Ref<DOMRectReadOnly | undefined>>;
+}
+export declare function useResizeObserver(callback?: ResizeObserverCallback): IUseResizeObserver;
+export {};

package/dist/composable/router.d.ts

@@ -0,0 +1,3 @@
+import type { NavigationGuardNext, Router } from 'vue-router';
+export declare function useRouter(): Router | undefined;
+export declare function useBackButton(router: Router | undefined, cb: (next: NavigationGuardNext) => void): void;

package/dist/composable/scopeId.d.ts

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

package/dist/composable/select.d.ts

@@ -0,0 +1,86 @@
+import { MaybePick } from '../utils';
+import type { PropType, ComputedRef, Ref } from 'vue';
+import type { IInternalItem, IUseItems } from './items';
+export interface ISelectProps {
+    multiple: boolean;
+    openOnClear: boolean;
+    hideSelected: boolean;
+    noDataText: string;
+    hideNoData: boolean;
+    isSelectAll: boolean;
+    selectAllText: string;
+    modelValue: any;
+}
+export declare const makeSelectProps: <Defaults extends {
+    multiple?: unknown;
+    openOnClear?: unknown;
+    hideSelected?: unknown;
+    noDataText?: unknown;
+    hideNoData?: unknown;
+    isSelectAll?: unknown;
+    selectAllText?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Множественный выбор элементов
+     */
+    multiple: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Открывать при очистке поля ввода
+     */
+    openOnClear: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Скрывать выбранные элементы из списка
+     */
+    hideSelected: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Текст, который будет отображаться, если нет данных
+     */
+    noDataText: {
+        type: PropType<string>;
+        default: string;
+    };
+    /**
+     * Скрывать отображаемый текст, если нет данных
+     */
+    hideNoData: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Добавляет возможность выбора всех элементов. Только для мультивыбора (multiple)
+     */
+    isSelectAll: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Текст для выбора всех элементов
+     */
+    selectAllText: {
+        type: PropType<string>;
+        default: string;
+    };
+}, Defaults>;
+export declare function useSelect(props: ISelectProps, items: ComputedRef<IInternalItem[]> | Ref<IInternalItem[]>, transformIn: IUseItems['transformIn'], transformOut: IUseItems['transformOut']): {
+    model: Ref<readonly IInternalItem<any>[]> & {
+        readonly externalValue: any;
+    };
+    selections: ComputedRef<IInternalItem<any>[]>;
+    selected: ComputedRef<any[]>;
+    selectedAll: ComputedRef<boolean>;
+    selectedIndeterminate: ComputedRef<boolean>;
+    selectStrategy: ComputedRef<"independent" | "single-independent">;
+    displayItems: ComputedRef<IInternalItem<any>[]>;
+};
+export declare function useFilteredSelectProps<Props extends Record<string, unknown>>(props: Props, filteredProps: Partial<Props>, excludes: Extract<keyof MaybePick<Props, Extract<keyof Props, string>>, string>[]): {
+    inputProps: [Partial<Props>] extends [Ref<any>] ? Ref<any> & Partial<Props> : Ref<import("vue").UnwrapRef<Partial<Props>>>;
+};

package/dist/composable/state.d.ts

@@ -0,0 +1,13 @@
+import type { Ref, UnwrapRef } from 'vue';
+/**
+ * Хук для работы с состоянием как в react.js на основе ref vue 3
+ * Может быть удобен в некоторых случаях
+ * @param defaultStateValue
+ */
+export declare function useState<T, R = Ref<T>>(defaultStateValue?: T | (() => T)): [R, (val: T) => void];
+export declare function useMergedState<T, R = Ref<T>>(defaultStateValue: T | (() => T), option?: {
+    defaultValue?: T | (() => T);
+    value?: Ref<T> | Ref<UnwrapRef<T>>;
+    onChange?: (val: T, prevValue: T) => void;
+    postState?: (val: T) => T;
+}): [R, (val: T) => void];

package/dist/composable/title.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef, PropType } from 'vue';
+export interface ITitleProps {
+    title: string;
+}
+export interface IUseTitle {
+}
+export interface IUseTitle {
+    hasTitle: ComputedRef<boolean>;
+}
+export declare const makeTitleProps: <Defaults extends {
+    title?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Заголовок
+     */
+    title: {
+        type: PropType<string>;
+        default: string;
+    };
+}, Defaults>;
+export declare function useTitle(props: ITitleProps, slots: Record<string, unknown>): IUseTitle;

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,112 @@
+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 {
+    error?: unknown;
+    errorMessages?: unknown;
+    maxErrors?: unknown;
+    name?: unknown;
+    rules?: unknown;
+    modelValue?: unknown;
+    validateOn?: unknown;
+    validationValue?: unknown;
+    hideMessages?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Состояние ошибки
+     */
+    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;
+    };
+    /**
+     * Правила валидации
+     */
+    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/create.d.ts

@@ -0,0 +1,23 @@
+import { ILocale, TAvailableLocale } from './locale';
+import type { App } from 'vue';
+import type { IDisplayOptions } from './composable';
+export interface ICdsOptions {
+    components?: Record<string, any>;
+    directives?: Record<string, any>;
+    icons?: Record<string, any>;
+    illustrations?: Record<string, any>;
+    display?: IDisplayOptions;
+    cssGrid?: boolean;
+    ssr?: boolean;
+    locale?: TAvailableLocale | ILocale;
+}
+interface NuxtApp {
+    $nuxt?: {
+        hook: (name: string, fn: () => void) => void;
+    };
+}
+export declare function createCds(options?: ICdsOptions): {
+    install: (app: App & NuxtApp) => void;
+    display: import("./composable").IDisplayInstance;
+};
+export {};

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,18 @@
+declare global {
+  interface HTMLCollection {
+    [Symbol.iterator](): IterableIterator<Element>;
+  }
+
+  interface HTMLElement {
+    _clickOutside?: Record<
+      number,
+      | {
+          onClick: EventListener;
+          onMousedown: EventListener;
+        }
+      | undefined
+    > & { lastMousedownWasOutside: boolean };
+  }
+
+  export const __VUE_OPTIONS_API__: boolean | undefined;
+}

package/dist/locale/en.d.ts

@@ -0,0 +1,3 @@
+import type { ILocale } from './';
+declare const _default: ILocale;
+export default _default;

package/dist/locale/index.d.ts

@@ -0,0 +1,13 @@
+import type { NTable } from '../components/CdsTable/interface';
+import type { TDateLocale } from '../utils';
+export interface ILocale {
+    table: NTable.ILocale;
+    date: TDateLocale;
+}
+export declare const availableLocale: readonly ["ru", "en"];
+export declare type TAvailableLocale = typeof availableLocale[number];
+declare const _default: {
+    ru: ILocale;
+    en: ILocale;
+};
+export default _default;

package/dist/locale/ru.d.ts

@@ -0,0 +1,3 @@
+import type { ILocale } from './';
+declare const _default: ILocale;
+export default _default;

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,243 @@ 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;
+}>;
+export declare const CdsTransitionSlideRight: 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 CdsTransitionSlideLeft: 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 CdsTransitionJumpRight: 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 CdsTransitionJumpLeft: 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 CdsTransitionScale: 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;
+}>;