@duxweb/dvha-pro 0.0.5

package/dist/types/components/layout/index.d.ts

@@ -0,0 +1,4 @@
+export * from './filter';
+export * from './list';
+export * from './table';
+export * from './tools';

package/dist/types/components/layout/list.d.ts

@@ -0,0 +1,85 @@
+import type { JsonSchemaNode } from '@duxweb/dvha-core';
+import type { TablePagination } from '@duxweb/dvha-naiveui';
+import type { PropType } from 'vue';
+import type { UseActionItem } from '../../hooks';
+export interface ListPageTools {
+    import?: boolean;
+    export?: boolean;
+    refresh?: boolean;
+}
+export declare const DuxListLayout: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+    filter: {
+        type: PropType<Record<string, any>>;
+    };
+    filterSchema: {
+        type: PropType<JsonSchemaNode[]>;
+    };
+    pagination: {
+        type: PropType<boolean | TablePagination>;
+        default: boolean;
+    };
+    tabs: {
+        type: PropType<{
+            label: string;
+            value: string | number;
+        }[]>;
+    };
+    tools: {
+        type: PropType<ListPageTools>;
+    };
+    actions: {
+        type: PropType<UseActionItem[]>;
+        default: () => never[];
+    };
+    checkable: {
+        type: BooleanConstructor;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+    filter: {
+        type: PropType<Record<string, any>>;
+    };
+    filterSchema: {
+        type: PropType<JsonSchemaNode[]>;
+    };
+    pagination: {
+        type: PropType<boolean | TablePagination>;
+        default: boolean;
+    };
+    tabs: {
+        type: PropType<{
+            label: string;
+            value: string | number;
+        }[]>;
+    };
+    tools: {
+        type: PropType<ListPageTools>;
+    };
+    actions: {
+        type: PropType<UseActionItem[]>;
+        default: () => never[];
+    };
+    checkable: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    checkable: boolean;
+    rowKey: string;
+    pagination: boolean | TablePagination;
+    actions: UseActionItem[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/layout/table.d.ts

@@ -0,0 +1,72 @@
+import type { JsonSchemaNode } from '@duxweb/dvha-core';
+import type { TableColumn, TablePagination } from '@duxweb/dvha-naiveui';
+import type { PropType } from 'vue';
+import type { UseActionItem } from '../../hooks';
+export interface TablePageTools {
+    import?: boolean;
+    export?: boolean;
+    refresh?: boolean;
+}
+export declare const DuxTableLayout: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+    filter: {
+        type: PropType<Record<string, any>>;
+    };
+    filterSchema: {
+        type: PropType<JsonSchemaNode[]>;
+    };
+    columns: {
+        type: PropType<TableColumn[]>;
+    };
+    pagination: {
+        type: PropType<boolean | TablePagination>;
+    };
+    tabs: {
+        type: PropType<{
+            label: string;
+            value: string | number;
+        }[]>;
+    };
+    actions: {
+        type: PropType<UseActionItem[]>;
+        default: () => never[];
+    };
+    tools: {
+        type: PropType<TablePageTools>;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+    filter: {
+        type: PropType<Record<string, any>>;
+    };
+    filterSchema: {
+        type: PropType<JsonSchemaNode[]>;
+    };
+    columns: {
+        type: PropType<TableColumn[]>;
+    };
+    pagination: {
+        type: PropType<boolean | TablePagination>;
+    };
+    tabs: {
+        type: PropType<{
+            label: string;
+            value: string | number;
+        }[]>;
+    };
+    actions: {
+        type: PropType<UseActionItem[]>;
+        default: () => never[];
+    };
+    tools: {
+        type: PropType<TablePageTools>;
+    };
+}>> & Readonly<{}>, {
+    actions: UseActionItem[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/layout/tools.d.ts

@@ -0,0 +1,37 @@
+import type { DropdownOption } from 'naive-ui';
+import type { PropType } from 'vue';
+export interface DuxToolOptionItem {
+    label?: string;
+    icon?: string;
+    onClick?: () => void;
+    loading?: boolean;
+    disabled?: boolean;
+    type?: 'default' | 'error' | 'success' | 'warning';
+}
+export declare const DuxTableTools: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    number: {
+        type: NumberConstructor;
+    };
+    options: {
+        type: PropType<DuxToolOptionItem[]>;
+    };
+    group: {
+        type: PropType<DuxToolOptionItem[][]>;
+    };
+    dropdown: {
+        type: PropType<DropdownOption[]>;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    number: {
+        type: NumberConstructor;
+    };
+    options: {
+        type: PropType<DuxToolOptionItem[]>;
+    };
+    group: {
+        type: PropType<DuxToolOptionItem[][]>;
+    };
+    dropdown: {
+        type: PropType<DropdownOption[]>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/list/card.d.ts

@@ -0,0 +1,117 @@
+import type { SlotsType } from 'vue';
+export interface CardPageSlotProps {
+    item: Record<string, any>;
+    isChecked: (id: string | number) => boolean;
+    toggleChecked: (id: string | number) => void;
+}
+export declare const DuxCardPage: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    colWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+    filter: {
+        type: import("vue").PropType<Record<string, any>>;
+    };
+    filterSchema: {
+        type: import("vue").PropType<import("@duxweb/dvha-core").JsonSchemaNode[]>;
+    };
+    pagination: {
+        type: import("vue").PropType<boolean | import("@duxweb/dvha-naiveui").TablePagination>;
+        default: boolean;
+    };
+    tabs: {
+        type: import("vue").PropType<{
+            label: string;
+            value: string | number;
+        }[]>;
+    };
+    tools: {
+        type: import("vue").PropType<import("..").ListPageTools>;
+    };
+    actions: {
+        type: import("vue").PropType<import("../..").UseActionItem[]>;
+        default: () => never[];
+    };
+    checkable: {
+        type: BooleanConstructor;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+    filter: {
+        type: import("vue").PropType<Record<string, any>>;
+    };
+    filterSchema: {
+        type: import("vue").PropType<import("@duxweb/dvha-core").JsonSchemaNode[]>;
+    };
+    pagination: {
+        type: import("vue").PropType<boolean | import("@duxweb/dvha-naiveui").TablePagination>;
+        default: boolean;
+    };
+    tabs: {
+        type: import("vue").PropType<{
+            label: string;
+            value: string | number;
+        }[]>;
+    };
+    tools: {
+        type: import("vue").PropType<import("..").ListPageTools>;
+    };
+    actions: {
+        type: import("vue").PropType<import("../..").UseActionItem[]>;
+        default: () => never[];
+    };
+    checkable: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    checkable: boolean;
+    rowKey: string;
+    pagination: boolean | import("@duxweb/dvha-naiveui").TablePagination;
+    actions: import("../..").UseActionItem[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    colWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    rows: number;
+    colWidth: number;
+    maxRows: number;
+}, SlotsType<{
+    default: (props: CardPageSlotProps) => any;
+    bottom: () => any;
+    tools: () => any;
+    actions: () => any;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/list/index.d.ts

@@ -0,0 +1,2 @@
+export * from './card';
+export * from './list';

package/dist/types/components/list/list.d.ts

@@ -0,0 +1,87 @@
+import type { SlotsType } from 'vue';
+export interface ListPageSlotProps {
+    item: Record<string, any>;
+    isChecked: (id: string | number) => boolean;
+    toggleChecked: (id: string | number) => void;
+}
+export declare const DuxListPage: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+    filter: {
+        type: import("vue").PropType<Record<string, any>>;
+    };
+    filterSchema: {
+        type: import("vue").PropType<import("@duxweb/dvha-core").JsonSchemaNode[]>;
+    };
+    pagination: {
+        type: import("vue").PropType<boolean | import("@duxweb/dvha-naiveui").TablePagination>;
+        default: boolean;
+    };
+    tabs: {
+        type: import("vue").PropType<{
+            label: string;
+            value: string | number;
+        }[]>;
+    };
+    tools: {
+        type: import("vue").PropType<import("..").ListPageTools>;
+    };
+    actions: {
+        type: import("vue").PropType<import("../..").UseActionItem[]>;
+        default: () => never[];
+    };
+    checkable: {
+        type: BooleanConstructor;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+    filter: {
+        type: import("vue").PropType<Record<string, any>>;
+    };
+    filterSchema: {
+        type: import("vue").PropType<import("@duxweb/dvha-core").JsonSchemaNode[]>;
+    };
+    pagination: {
+        type: import("vue").PropType<boolean | import("@duxweb/dvha-naiveui").TablePagination>;
+        default: boolean;
+    };
+    tabs: {
+        type: import("vue").PropType<{
+            label: string;
+            value: string | number;
+        }[]>;
+    };
+    tools: {
+        type: import("vue").PropType<import("..").ListPageTools>;
+    };
+    actions: {
+        type: import("vue").PropType<import("../..").UseActionItem[]>;
+        default: () => never[];
+    };
+    checkable: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    checkable: boolean;
+    rowKey: string;
+    pagination: boolean | import("@duxweb/dvha-naiveui").TablePagination;
+    actions: import("../..").UseActionItem[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
+    default: (props: ListPageSlotProps) => any;
+    bottom: () => any;
+    tools: () => any;
+    actions: () => any;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/media/index.d.ts

@@ -0,0 +1 @@
+export * from './media';

package/dist/types/components/media/media.d.ts

@@ -0,0 +1,95 @@
+export declare const DuxMedia: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    title: StringConstructor;
+    avatar: BooleanConstructor;
+    image: (StringConstructor | {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    })[];
+    desc: (StringConstructor | {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    })[];
+    extend: StringConstructor;
+    onClick: FunctionConstructor;
+    imageWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    imageHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: StringConstructor;
+    avatar: BooleanConstructor;
+    image: (StringConstructor | {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    })[];
+    desc: (StringConstructor | {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    })[];
+    extend: StringConstructor;
+    onClick: FunctionConstructor;
+    imageWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    imageHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    avatar: boolean;
+    imageWidth: number;
+    imageHeight: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/modal/index.d.ts

@@ -0,0 +1,3 @@
+export * from './modal';
+export { default as ModalPage } from './modalPage';
+export { default as ModalTab } from './modalTab';

package/dist/types/components/modal/modal.d.ts

@@ -0,0 +1,66 @@
+import type { PropType } from 'vue';
+export declare const DuxModal: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    component: {
+        type: PropType<() => any>;
+    };
+    componentProps: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onClose: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    onConfirm: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    component: {
+        type: PropType<() => any>;
+    };
+    componentProps: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onClose: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    onConfirm: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    title: string;
+    draggable: boolean;
+    componentProps: Record<string, any>;
+    width: number;
+    onConfirm: () => void;
+    onClose: () => void;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default DuxModal;

package/dist/types/components/modal/modalPage.d.ts

@@ -0,0 +1,42 @@
+import type { PropType, Ref } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    handle: {
+        type: PropType<Ref<HTMLElement>>;
+        default: () => Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    };
+    onClose: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    handle: {
+        type: PropType<Ref<HTMLElement>>;
+        default: () => Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    };
+    onClose: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+}>> & Readonly<{}>, {
+    title: string;
+    draggable: boolean;
+    onClose: () => void;
+    handle: Ref<HTMLElement, HTMLElement>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/modal/modalTab.d.ts

@@ -0,0 +1,42 @@
+import type { PropType, Ref } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultTab: {
+        type: StringConstructor;
+        default: string;
+    };
+    handle: {
+        type: PropType<Ref<HTMLElement>>;
+        default: () => Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    };
+    onClose: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultTab: {
+        type: StringConstructor;
+        default: string;
+    };
+    handle: {
+        type: PropType<Ref<HTMLElement>>;
+        default: () => Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    };
+    onClose: {
+        type: PropType<() => void>;
+        default: () => void;
+    };
+}>> & Readonly<{}>, {
+    draggable: boolean;
+    onClose: () => void;
+    handle: Ref<HTMLElement, HTMLElement>;
+    defaultTab: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;