@wimi/ui 0.4.20 → 0.4.21

package/dist/src/components/splitter/src/panel.vue.d.ts

@@ -0,0 +1,355 @@
+import { SplitterPanelProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        panelRef: {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{}> & Omit<{
+                readonly collapsedSize?: number;
+                readonly collapsible?: boolean;
+                readonly defaultSize?: number;
+                readonly id?: string;
+                readonly maxSize?: number;
+                readonly minSize?: number;
+                readonly order?: number;
+                readonly asChild?: boolean;
+                readonly as?: import('reka-ui').AsTag | import('vue').Component;
+                readonly onResize?: (size: number, prevSize: number) => any;
+                readonly onCollapse?: () => any;
+                readonly onExpand?: () => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                splitterPanelRef: {
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly collapsedSize?: number;
+                        readonly collapsible?: boolean;
+                        readonly defaultSize?: number;
+                        readonly id?: string;
+                        readonly maxSize?: number;
+                        readonly minSize?: number;
+                        readonly order?: number;
+                        readonly asChild?: boolean;
+                        readonly as?: import('reka-ui').AsTag | import('vue').Component;
+                        readonly onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
+                        readonly onCollapse?: (() => any) | undefined;
+                        readonly onExpand?: (() => any) | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any>;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: ((event: "resize", size: number, prevSize: number) => void) & ((event: "collapse") => void) & ((event: "expand") => void);
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').SplitterPanelProps> & Readonly<{
+                        onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
+                        onCollapse?: (() => any) | undefined;
+                        onExpand?: (() => any) | undefined;
+                    }>, {
+                        collapse: () => void;
+                        expand: () => void;
+                        getSize(): number;
+                        resize: (size: number) => void;
+                        isCollapsed: import('vue').ComputedRef<boolean>;
+                        isExpanded: import('vue').ComputedRef<boolean>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        resize: (size: number, prevSize: number | undefined) => any;
+                        collapse: () => any;
+                        expand: () => any;
+                    }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                        beforeCreate?: (() => void) | (() => void)[];
+                        created?: (() => void) | (() => void)[];
+                        beforeMount?: (() => void) | (() => void)[];
+                        mounted?: (() => void) | (() => void)[];
+                        beforeUpdate?: (() => void) | (() => void)[];
+                        updated?: (() => void) | (() => void)[];
+                        activated?: (() => void) | (() => void)[];
+                        deactivated?: (() => void) | (() => void)[];
+                        beforeDestroy?: (() => void) | (() => void)[];
+                        beforeUnmount?: (() => void) | (() => void)[];
+                        destroyed?: (() => void) | (() => void)[];
+                        unmounted?: (() => void) | (() => void)[];
+                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof import('vue').nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                } & Readonly<{}> & Omit<Readonly<import('reka-ui').SplitterPanelProps> & Readonly<{
+                    onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
+                    onCollapse?: (() => any) | undefined;
+                    onExpand?: (() => any) | undefined;
+                }>, "resize" | "collapse" | "expand" | "getSize" | "isCollapsed" | "isExpanded"> & import('vue').ShallowUnwrapRef<{
+                    collapse: () => void;
+                    expand: () => void;
+                    getSize(): number;
+                    resize: (size: number) => void;
+                    isCollapsed: import('vue').ComputedRef<boolean>;
+                    isExpanded: import('vue').ComputedRef<boolean>;
+                }> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        default?: (props: {
+                            isCollapsed: boolean;
+                            isExpanded: boolean;
+                            collapse: () => void;
+                            expand: () => void;
+                            resize: (size: number) => void;
+                        }) => any;
+                    };
+                };
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "resize", size: number, prevSize: number) => void) & ((event: "collapse") => void) & ((event: "expand") => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').SplitterPanelProps> & Readonly<{
+                onResize?: (size: number, prevSize: number) => any;
+                onCollapse?: () => any;
+                onExpand?: () => any;
+            }>, {
+                getSplitterPanelRef: () => any;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                resize: (size: number, prevSize: number) => any;
+                collapse: () => any;
+                expand: () => any;
+            }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{}> & Omit<Readonly<import('reka-ui').SplitterPanelProps> & Readonly<{
+            onResize?: (size: number, prevSize: number) => any;
+            onCollapse?: () => any;
+            onExpand?: () => any;
+        }>, "getSplitterPanelRef"> & import('vue').ShallowUnwrapRef<{
+            getSplitterPanelRef: () => any;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        };
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SplitterPanelProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    resize: (size: number, prevSize: number) => any;
+    collapse: () => any;
+    expand: () => any;
+}, string, import('vue').PublicProps, Readonly<SplitterPanelProps> & Readonly<{
+    onResize?: (size: number, prevSize: number) => any;
+    onCollapse?: () => any;
+    onExpand?: () => any;
+}>, {
+    collapsible: import('reka-ui').SplitterPanelProps["collapsible"];
+    withHandle: boolean;
+    border: boolean;
+    collapsedSize: import('reka-ui').SplitterPanelProps["collapsedSize"];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    panelRef: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{
+            readonly collapsedSize?: number;
+            readonly collapsible?: boolean;
+            readonly defaultSize?: number;
+            readonly id?: string;
+            readonly maxSize?: number;
+            readonly minSize?: number;
+            readonly order?: number;
+            readonly asChild?: boolean;
+            readonly as?: import('reka-ui').AsTag | import('vue').Component;
+            readonly onResize?: (size: number, prevSize: number) => any;
+            readonly onCollapse?: () => any;
+            readonly onExpand?: () => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            splitterPanelRef: {
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly collapsedSize?: number;
+                    readonly collapsible?: boolean;
+                    readonly defaultSize?: number;
+                    readonly id?: string;
+                    readonly maxSize?: number;
+                    readonly minSize?: number;
+                    readonly order?: number;
+                    readonly asChild?: boolean;
+                    readonly as?: import('reka-ui').AsTag | import('vue').Component;
+                    readonly onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
+                    readonly onCollapse?: (() => any) | undefined;
+                    readonly onExpand?: (() => any) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any>;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: ((event: "resize", size: number, prevSize: number) => void) & ((event: "collapse") => void) & ((event: "expand") => void);
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').SplitterPanelProps> & Readonly<{
+                    onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
+                    onCollapse?: (() => any) | undefined;
+                    onExpand?: (() => any) | undefined;
+                }>, {
+                    collapse: () => void;
+                    expand: () => void;
+                    getSize(): number;
+                    resize: (size: number) => void;
+                    isCollapsed: import('vue').ComputedRef<boolean>;
+                    isExpanded: import('vue').ComputedRef<boolean>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    resize: (size: number, prevSize: number | undefined) => any;
+                    collapse: () => any;
+                    expand: () => any;
+                }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import('vue').nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+            } & Readonly<{}> & Omit<Readonly<import('reka-ui').SplitterPanelProps> & Readonly<{
+                onResize?: ((size: number, prevSize: number | undefined) => any) | undefined;
+                onCollapse?: (() => any) | undefined;
+                onExpand?: (() => any) | undefined;
+            }>, "resize" | "collapse" | "expand" | "getSize" | "isCollapsed" | "isExpanded"> & import('vue').ShallowUnwrapRef<{
+                collapse: () => void;
+                expand: () => void;
+                getSize(): number;
+                resize: (size: number) => void;
+                isCollapsed: import('vue').ComputedRef<boolean>;
+                isExpanded: import('vue').ComputedRef<boolean>;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?: (props: {
+                        isCollapsed: boolean;
+                        isExpanded: boolean;
+                        collapse: () => void;
+                        expand: () => void;
+                        resize: (size: number) => void;
+                    }) => any;
+                };
+            };
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "resize", size: number, prevSize: number) => void) & ((event: "collapse") => void) & ((event: "expand") => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').SplitterPanelProps> & Readonly<{
+            onResize?: (size: number, prevSize: number) => any;
+            onCollapse?: () => any;
+            onExpand?: () => any;
+        }>, {
+            getSplitterPanelRef: () => any;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            resize: (size: number, prevSize: number) => any;
+            collapse: () => any;
+            expand: () => any;
+        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<import('reka-ui').SplitterPanelProps> & Readonly<{
+        onResize?: (size: number, prevSize: number) => any;
+        onCollapse?: () => any;
+        onExpand?: () => any;
+    }>, "getSplitterPanelRef"> & import('vue').ShallowUnwrapRef<{
+        getSplitterPanelRef: () => any;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    };
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/splitter/src/splitter.vue.d.ts

@@ -0,0 +1,18 @@
+import { SplitterProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<Record<string, any>> & Record<string, any>;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SplitterProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SplitterProps> & Readonly<{}>, {
+    layout: import('reka-ui').SplitterGroupProps["direction"];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/{typings → src}/components/splitter/src/types.d.ts

@@ -1,5 +1,5 @@
-import type { SplitterPanelProps as RSplitterPanelProps, SplitterGroupProps } from 'reka-ui';
-import type { HTMLAttributes } from 'vue';
+import { SplitterPanelProps as RSplitterPanelProps, SplitterGroupProps } from 'reka-ui';
+import { HTMLAttributes } from 'vue';
 /**
  * SplitterPanel 组件的属性接口
  */

package/dist/src/components/status-card/src/index.vue.d.ts

@@ -0,0 +1,35 @@
+import { WmStatusCardProps } from './types';
+type __VLS_Props = WmStatusCardProps;
+type __VLS_PublicProps = {
+    'actived'?: number | number[];
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        action?(_: {}): any;
+        extra?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    auto: (...args: any[]) => void;
+    refresh: (...args: any[]) => void;
+    "status-click": (...args: any[]) => void;
+    "update:actived": (value: number | number[]) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onAuto?: (...args: any[]) => any;
+    onRefresh?: (...args: any[]) => any;
+    "onStatus-click"?: (...args: any[]) => any;
+    "onUpdate:actived"?: (value: number | number[]) => any;
+}>, {
+    actions: ("auto" | "refresh")[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/{typings → src}/components/status-card/src/types.d.ts

@@ -1,4 +1,4 @@
-import type { HTMLAttributes, Slot, VNode } from 'vue';
+import { HTMLAttributes, Slot, VNode } from 'vue';
 type Item = {
     image: string;
     label: string | VNode | Slot;

package/dist/src/components/table/demo/adapter/component/index.d.ts

@@ -0,0 +1,33 @@
+import { ApiComponentProps, BaseFormComponentProps } from '../../../../..';
+import { Component, VNodeProps } from 'vue';
+type ExtractPropTypes<T extends Component> = T extends new (...args: any) => any ? Omit<InstanceType<T>['$props'], keyof VNodeProps> : never;
+export type AntComponentProps = {
+    ApiSelect: Partial<ApiComponentProps>;
+    ApiTreeSelect: Partial<ApiComponentProps>;
+    ApiTableSelect: Partial<ApiComponentProps>;
+    AutoComplete: ExtractPropTypes<(typeof import('ant-design-vue/es/auto-complete'))['default']>;
+    Checkbox: ExtractPropTypes<(typeof import('ant-design-vue/es/checkbox'))['default']>;
+    CheckboxGroup: ExtractPropTypes<(typeof import('ant-design-vue/es/checkbox'))['CheckboxGroup']>;
+    DatePicker: ExtractPropTypes<(typeof import('ant-design-vue/es/date-picker'))['default']>;
+    Divider: ExtractPropTypes<(typeof import('ant-design-vue/es/divider'))['default']>;
+    Input: ExtractPropTypes<(typeof import('ant-design-vue/es/input'))['default']>;
+    InputNumber: ExtractPropTypes<(typeof import('ant-design-vue/es/input-number'))['default']>;
+    InputPassword: ExtractPropTypes<(typeof import('ant-design-vue/es/input'))['InputPassword']>;
+    Mentions: ExtractPropTypes<(typeof import('ant-design-vue/es/mentions'))['default']>;
+    Radio: ExtractPropTypes<(typeof import('ant-design-vue/es/radio'))['default']>;
+    RadioGroup: ExtractPropTypes<(typeof import('ant-design-vue/es/radio'))['RadioGroup']>;
+    RangePicker: ExtractPropTypes<(typeof import('ant-design-vue/es/date-picker'))['RangePicker']>;
+    Rate: ExtractPropTypes<(typeof import('ant-design-vue/es/rate'))['default']>;
+    Select: ExtractPropTypes<(typeof import('ant-design-vue/es/select'))['default']>;
+    Switch: ExtractPropTypes<(typeof import('ant-design-vue/es/switch'))['default']>;
+    Textarea: ExtractPropTypes<(typeof import('ant-design-vue/es/input'))['Textarea']>;
+    TimePicker: ExtractPropTypes<(typeof import('ant-design-vue/es/time-picker'))['TimePicker']>;
+    TreeSelect: ExtractPropTypes<(typeof import('ant-design-vue/es/tree-select'))['default']>;
+    Upload: ExtractPropTypes<(typeof import('ant-design-vue/es/upload'))['default']>;
+    Cascader: ExtractPropTypes<(typeof import('ant-design-vue/es/cascader'))['default']>;
+    Slider: ExtractPropTypes<(typeof import('ant-design-vue/es/slider'))['default']>;
+    TimeRangePicker: ExtractPropTypes<(typeof import('ant-design-vue/es/time-picker'))['TimeRangePicker']>;
+} & BaseFormComponentProps;
+export type ComponentType = keyof AntComponentProps;
+declare function initComponentAdapter(): Promise<void>;
+export { initComponentAdapter };

package/dist/src/components/table/demo/adapter/form.d.ts

@@ -0,0 +1,7 @@
+import { FormProps, z } from '../../../..';
+import { AntComponentProps } from './component';
+declare const useWmForm: (options: FormProps<AntComponentProps>) => readonly [import('vue').DefineSetupFnComponent<FormProps<import('../../../..').BaseFormComponentProps>, {}, {}, FormProps<import('../../../..').BaseFormComponentProps> & {}, import('vue').PublicProps>, Partial<{
+    useStore: <T = NoInfer<FormProps>>(selector?: (state: NoInfer<FormProps>) => T) => Readonly<import('vue').Ref<T>>;
+} & import('../../../form/src/form-api').FormApi>];
+export { useWmForm, z };
+export type WmFromProps = FormProps<AntComponentProps>;

package/dist/src/components/table/demo/adapter/table.d.ts

@@ -0,0 +1,2 @@
+import { AntComponentProps } from './component';
+export declare const useWmTable: (options: import('../../src/types').VxeGridProps<AntComponentProps>) => readonly [import('vue').DefineSetupFnComponent<import('../../src/types').VxeGridProps<import('../../../..').BaseFormComponentProps>, {}, {}, import('../../src/types').VxeGridProps<import('../../../..').BaseFormComponentProps> & {}, import('vue').PublicProps>, import('../../src/types').ExtendedVxeGridApi];

package/dist/{typings → src}/components/table/src/api.d.ts

@@ -1,7 +1,7 @@
-import type { ExtendedFormApi } from '@/components/form';
+import { ExtendedFormApi } from '../../form';
 import { Store } from '@tanstack/vue-store';
-import type { VxeGridInstance } from 'vxe-table';
-import type { VxeGridProps } from './types';
+import { VxeGridInstance } from 'vxe-table';
+import { VxeGridProps } from './types';
 export declare class VxeGridApi {
     formApi: ExtendedFormApi;
     grid: VxeGridInstance;

package/dist/{typings → src}/components/table/src/extends.d.ts

@@ -1,5 +1,5 @@
-import type { Recordable } from '@/typings';
-import type { VxeGridProps, VxeUIExport } from 'vxe-table';
-import type { VxeGridApi } from './api';
+import { Recordable } from '../../../typings';
+import { VxeGridProps, VxeUIExport } from 'vxe-table';
+import { VxeGridApi } from './api';
 export declare function extendProxyOptions(api: VxeGridApi, options: VxeGridProps, getFormValues: () => Recordable<any>): void;
 export declare function extendsDefaultFormatter(vxeUI: VxeUIExport): void;

package/dist/{typings → src}/components/table/src/init.d.ts

@@ -1,5 +1,5 @@
-import type { useForm } from '@/components/form';
-import type { SetupVxeTable } from './types';
+import { useForm } from '../../form';
+import { SetupVxeTable } from './types';
 export declare let useTableForm: typeof useForm;
 export declare function initVxeTable(): void;
 export declare function setupWmTable(setupOptions: SetupVxeTable): void;

package/dist/{typings → src}/components/table/src/types.d.ts

@@ -1,8 +1,8 @@
-import type { Ref } from 'vue';
-import type { VxeGridListeners, VxeGridPropTypes, VxeGridProps as VxeTableGridProps, VxeUIExport } from 'vxe-table';
-import type { BaseFormComponentProps, FormProps, useForm } from '../../../components/form';
-import type { ClassType } from '../../../typings';
-import type { VxeGridApi } from './api';
+import { Ref } from 'vue';
+import { VxeGridListeners, VxeGridPropTypes, VxeGridProps as VxeTableGridProps, VxeUIExport } from 'vxe-table';
+import { BaseFormComponentProps, FormProps, useForm } from '../../../components/form';
+import { ClassType } from '../../../typings';
+import { VxeGridApi } from './api';
 export interface VxePaginationInfo {
     currentPage: number;
     pageSize: number;

package/dist/src/components/table/src/use-table.d.ts

@@ -0,0 +1,4 @@
+import { BaseFormComponentProps } from '../../form';
+import { ExtendedVxeGridApi, VxeGridProps } from './types';
+export declare function useTable<T extends BaseFormComponentProps = BaseFormComponentProps>(options: VxeGridProps<T>): readonly [import('vue').DefineSetupFnComponent<VxeGridProps<BaseFormComponentProps>, {}, {}, VxeGridProps<BaseFormComponentProps> & {}, import('vue').PublicProps>, ExtendedVxeGridApi];
+export type useTable = typeof useTable;