@vue-ui-kit/ant 2.4.1 → 2.4.3

package/dist/index.d.ts

@@ -8,7 +8,7 @@ import { default as PGroupBlock } from './packages/components/PGroupBlock.vue';
 import { default as PromisePicker } from './packages/components/PromisePicker.vue';
 import { addFormatter } from './packages/utils/AFormatters';
 import { addRender } from './packages/store/renderStore';
-import { setUIKitConfig, getUIKitConfig, resetUIKitConfig, UIKitConfig } from './packages/utils/config';
+import { setUIKitConfig, getUIKitConfig, resetUIKitConfig, getTooltipRenderer, UIKitConfig } from './packages/utils/config';
 declare function setup(config?: Partial<UIKitConfig>): void;
 declare const _default: {
     install(app: App): void;
@@ -19,5 +19,5 @@ declare const _default: {
 export default _default;
 export * from './declarations/antProxy';
 export * from './packages/utils/core';
-export { setup, setUIKitConfig, getUIKitConfig, resetUIKitConfig, type UIKitConfig };
+export { setup, setUIKitConfig, getUIKitConfig, resetUIKitConfig, getTooltipRenderer, type UIKitConfig, };
 export { PForm, PGrid, PCanvasTable, PCanvasGrid, PFormGroup, PGroupBlock, PromisePicker, addFormatter, addRender, };

package/dist/packages/components/CollapseCard.vue.d.ts

@@ -0,0 +1,29 @@
+interface Props {
+    /** 是否默认折叠 */
+    defaultCollapsed?: boolean;
+    title?: string;
+    /** 是否可以折叠 */
+    collapsible?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: any;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    collapse: () => void;
+    expand: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    title: string;
+    defaultCollapsed: boolean;
+    collapsible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, 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/packages/components/PCanvasTable.vue.d.ts

@@ -0,0 +1,177 @@
+import { default as Cell } from 'e-virt-table/dist/lib/Cell';
+import { default as EVirtTable, Column as EVirtColumn, FormatterMethod } from 'e-virt-table';
+import { CanvasTableProps } from '../../declarations/antProxy';
+declare const _default: <T extends Recordable = Recordable, B extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onChange?: ((value: any[]) => any) | undefined;
+        readonly onSelectionChange?: ((value: T[]) => any) | undefined;
+        readonly onReady?: ((value: EVirtTable) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onChange" | "onSelectionChange" | "onReady"> & CanvasTableProps<T, B> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        $table: null;
+        selectedRecords: import('vue').ComputedRef<import('@vue/reactivity').UnwrapRefSimple<T>[]>;
+        reloadData: () => void;
+    }>): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        cell: Cell | import('e-virt-table/dist/lib/CellHeader').default;
+        formatter?: FormatterMethod;
+        formatterFooter?: FormatterMethod;
+        hoverIconName?: string;
+        operation: boolean;
+        align: import('e-virt-table').Align;
+        verticalAlign: import('e-virt-table').VerticalAlign;
+        fixed?: import('e-virt-table').Fixed;
+        type: import('e-virt-table').Type | "";
+        editorType: string;
+        editorProps: any;
+        cellType: import('e-virt-table').CellType;
+        level: number;
+        colspan: number;
+        rowspan: number;
+        mergeRow: boolean;
+        mergeCol: boolean;
+        relationRowKeys: string[];
+        relationColKeys: string[];
+        key: string;
+        column: EVirtColumn;
+        rowIndex: number;
+        colIndex: number;
+        rowKey: string;
+        row: any;
+        value: any;
+        render: import('e-virt-table').Render;
+        renderFooter: import('e-virt-table').Render;
+        style: any;
+        domDataset: any;
+        rules: import('e-virt-table/dist/lib/Validator').Rules | import('e-virt-table/dist/lib/Validator').Rule;
+        message: string;
+        text: string;
+        displayText: string;
+        visibleWidth: number;
+        visibleHeight: number;
+        isHasChanged: boolean;
+        drawX: number;
+        drawY: number;
+        drawCellBgColor: string;
+        drawCellSkyBgColor: string;
+        drawTextColor: string;
+        drawTextFont: string;
+        drawTextX: number;
+        drawTextY: number;
+        drawTextWidth: number;
+        drawTextHeight: number;
+        drawTreeImageX: number;
+        drawTreeImageY: number;
+        drawTreeImageWidth: number;
+        drawTreeImageHeight: number;
+        drawTreeImageName: string;
+        drawTreeImageSource?: HTMLImageElement;
+        drawSelectionImageX: number;
+        drawSelectionImageY: number;
+        drawSelectionImageWidth: number;
+        drawSelectionImageHeight: number;
+        drawSelectionImageName: string;
+        drawSelectionImageSource?: HTMLImageElement;
+        drawHoverImageX: number;
+        drawHoverImageY: number;
+        drawHoverImageWidth: number;
+        drawHoverImageHeight: number;
+        drawHoverImageName: string;
+        drawHoverImageSource?: HTMLImageElement;
+        autoRowHeight: boolean;
+        calculatedHeight: number;
+        ellipsis: boolean;
+        rowExpand: boolean;
+        rowHasChildren: boolean;
+        overflowTooltipShow: boolean;
+        selectorCellValueType: import('e-virt-table').SelectorCellValueType;
+        overflowTooltipMaxWidth: number;
+        overflowTooltipPlacement: import('e-virt-table').OverflowTooltipPlacement;
+        maxLineClamp: import('e-virt-table').LineClampType;
+        ctx: import('e-virt-table/dist/lib/Context').default;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | {
+        cell: Cell | import('e-virt-table/dist/lib/CellHeader').default;
+        align: import('e-virt-table').Align;
+        hideHeaderSelection: boolean;
+        verticalAlign: import('e-virt-table').VerticalAlign;
+        fixed?: import('e-virt-table').Fixed;
+        minWidth?: number;
+        maxWidth?: number;
+        widthFillDisable: boolean;
+        type: import('e-virt-table').Type | "";
+        operation: boolean;
+        editorType: string;
+        level: number;
+        text: string;
+        hide: boolean;
+        displayText: string;
+        colspan: number;
+        rowspan: number;
+        row: any;
+        key: string;
+        required: boolean;
+        readonly: boolean;
+        ellipsis: boolean;
+        overflowTooltipShow: boolean;
+        children: EVirtColumn[];
+        column: EVirtColumn;
+        colIndex: number;
+        rowKey: string;
+        rules?: import('e-virt-table/dist/lib/Validator').Rules | import('e-virt-table/dist/lib/Validator').Rule;
+        hasChildren: boolean;
+        render: import('e-virt-table').Render;
+        style: Partial<CSSStyleDeclaration>;
+        drawX: number;
+        drawY: number;
+        sortIconName: string;
+        sortAscIconName: string;
+        sortDescIconName: string;
+        visibleWidth: number;
+        visibleHeight: number;
+        maxLineClampHeader: import('e-virt-table').LineClampType;
+        domDataset: any;
+        drawTextX: number;
+        drawTextY: number;
+        drawTextWidth: number;
+        drawTextHeight: number;
+        drawCellBgColor: string;
+        drawTextColor: string;
+        drawTextFont: string;
+        drawSelectionImageX: number;
+        drawSelectionImageY: number;
+        drawSelectionImageWidth: number;
+        drawSelectionImageHeight: number;
+        drawSelectionImageName: string;
+        drawSelectionImageSource?: HTMLImageElement;
+        drawSortImageX: number;
+        drawSortImageY: number;
+        drawSortImageWidth: number;
+        drawSortImageHeight: number;
+        drawSortImageName: string;
+        drawSortImageSource?: HTMLImageElement;
+        ctx: import('e-virt-table/dist/lib/Context').default;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        cellType: import('e-virt-table').CellType;
+    }) => any>> & {
+        empty?(_: {}): any;
+    };
+    emit: {
+        (e: "change", value: any[]): void;
+        (e: "selectionChange", value: T[]): void;
+        (e: "ready", value: EVirtTable): void;
+    };
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/packages/components/PForm.vue.d.ts

@@ -0,0 +1,22 @@
+import { PFormProps } from '../../declarations/antProxy';
+declare const _default: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onReset?: ((...args: any[]) => any) | undefined;
+        readonly onApply?: ((...args: any[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onReset" | "onApply"> & (PFormProps<F> & {
+        data: F;
+    }) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        reset: () => void;
+        $form: import('vue').ComputedRef<any>;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: (event: "reset" | "apply", ...args: any[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/packages/components/PFormCol.vue.d.ts

@@ -0,0 +1,23 @@
+import { PFormItemProps } from '../../declarations/antProxy';
+declare const _default: <T extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onTrigger?: ((cusFields?: string | string[] | undefined) => any) | undefined;
+        readonly onReset?: (() => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onReset" | "onTrigger"> & {
+        item: PFormItemProps<T>;
+        formData: T;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {
+        (e: "trigger", cusFields?: string | string[]): void;
+        (e: "reset"): void;
+    };
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/packages/components/PFormGroup.vue.d.ts

@@ -0,0 +1,38 @@
+import { PFormGroupProps } from '../../declarations/antProxy';
+declare const _default: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: Partial<F & {
+            __index: number;
+        }>[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
+        modelValue?: Partial<F & {
+            __index: number;
+        }>[];
+    } & PFormGroupProps<F>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        collapse: () => void;
+        expand: () => void;
+        activeKey: import('vue').ComputedRef<number>;
+        setActiveKey: (key: number) => void;
+        validateAll: () => Promise<PromiseSettledResult<any>[]>;
+        validate: (__index: number, ignoreTabError?: boolean) => Promise<void>;
+        validateFields: (__index: number, fields: string[], ignoreTabError?: boolean) => Promise<void>;
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        [key: string]: any;
+        rightExtra?: () => any;
+    }> & {
+        [key: string]: any;
+        rightExtra?: () => any;
+    };
+    emit: (evt: "update:modelValue", value: Partial<F & {
+        __index: number;
+    }>[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/packages/components/PGroupBlock.vue.d.ts

@@ -0,0 +1,16 @@
+import { PBlockProps } from '../../declarations/antProxy';
+declare const _default: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & PBlockProps<F> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        $form: import('vue').ComputedRef<Recordable<any> | undefined>;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/packages/components/PromisePicker.vue.d.ts

@@ -0,0 +1,25 @@
+import { PGridInstance, PromisePickerProps } from '../../declarations/antProxy';
+declare const _default: <D extends Recordable = Recordable, F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & PromisePickerProps<D, F> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        pick: () => Promise<D[] | {
+            row: D;
+            field?: string;
+        }>;
+        pickMultiple: () => Promise<D[] | {
+            row: D;
+            field?: string;
+        }>;
+        grid: import('vue').Ref<PGridInstance<D, Recordable<any>> | undefined, PGridInstance<D, Recordable<any>> | undefined>;
+        hide: () => void;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/packages/components/RenderAntCell.d.ts

@@ -1,10 +1,28 @@
-declare const _default: import('vue').DefineSetupFnComponent<{
-    cellRender: any;
-    renderTableParams: any;
-    defaultHandler: any;
-}, {}, {}, {
-    cellRender: any;
-    renderTableParams: any;
-    defaultHandler: any;
-} & {}, import('vue').PublicProps>;
+import { CellRender, RenderTableParams } from '../../declarations/antProxy';
+declare const _default: new <D extends Recordable = Recordable<any>>(props: {
+    cellRender: CellRender;
+    renderTableParams: RenderTableParams<D>;
+    defaultHandler?: {
+        [key: string]: (...args: any[]) => any;
+    };
+} & {} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps) => import('vue').CreateComponentPublicInstanceWithMixins<{
+    cellRender: CellRender;
+    renderTableParams: RenderTableParams<D>;
+    defaultHandler?: {
+        [key: string]: (...args: any[]) => any;
+    };
+} & {}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, {}, {}, string, {}, any, import('vue').ComponentProvideOptions, {
+    P: {};
+    B: {};
+    D: {};
+    C: {};
+    M: {};
+    Defaults: {};
+}, {
+    cellRender: CellRender;
+    renderTableParams: RenderTableParams<D>;
+    defaultHandler?: {
+        [key: string]: (...args: any[]) => any;
+    };
+} & {}, {}, {}, {}, {}, {}>;
 export default _default;

package/dist/packages/components/RenderDefaultSlots.d.ts

@@ -1,14 +1,34 @@
-declare const _default: import('vue').DefineSetupFnComponent<{
-    row: any;
-    column: any;
-    rowIndex: any;
-    defaultHandler: any;
-    tableData: any;
-}, {}, {}, {
-    row: any;
-    column: any;
-    rowIndex: any;
-    defaultHandler: any;
-    tableData: any;
-} & {}, import('vue').PublicProps>;
+import { ColumnProps } from '../../declarations/antProxy';
+declare const _default: new <D extends Recordable = Recordable<any>>(props: {
+    tableData: D[];
+    row: D;
+    column: ColumnProps<D>;
+    rowIndex: number;
+    defaultHandler?: {
+        [key: string]: (...args: any[]) => any;
+    };
+} & {} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps) => import('vue').CreateComponentPublicInstanceWithMixins<{
+    tableData: D[];
+    row: D;
+    column: ColumnProps<D>;
+    rowIndex: number;
+    defaultHandler?: {
+        [key: string]: (...args: any[]) => any;
+    };
+} & {}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, {}, {}, string, {}, any, import('vue').ComponentProvideOptions, {
+    P: {};
+    B: {};
+    D: {};
+    C: {};
+    M: {};
+    Defaults: {};
+}, {
+    tableData: D[];
+    row: D;
+    column: ColumnProps<D>;
+    rowIndex: number;
+    defaultHandler?: {
+        [key: string]: (...args: any[]) => any;
+    };
+} & {}, {}, {}, {}, {}, {}>;
 export default _default;

package/dist/packages/components/RenderEditCell.d.ts

@@ -1,10 +1,25 @@
-declare const _default: import('vue').DefineSetupFnComponent<{
-    cellRender: any;
-    renderTableParams: any;
-}, "blur"[], {}, {
-    cellRender: any;
-    renderTableParams: any;
+import { CellRender, RenderTableParams } from '../../declarations/antProxy';
+declare const _default: new <D extends Recordable = Recordable<any>>(props: {
+    cellRender: CellRender;
+    renderTableParams: RenderTableParams<D>;
 } & {
     onBlur?: ((...args: any[]) => any) | undefined;
-}, import('vue').PublicProps>;
+} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps) => import('vue').CreateComponentPublicInstanceWithMixins<{
+    cellRender: CellRender;
+    renderTableParams: RenderTableParams<D>;
+} & {
+    onBlur?: ((...args: any[]) => any) | undefined;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "blur"[], import('vue').PublicProps, {}, false, {}, {}, {}, {}, string, {}, any, import('vue').ComponentProvideOptions, {
+    P: {};
+    B: {};
+    D: {};
+    C: {};
+    M: {};
+    Defaults: {};
+}, {
+    cellRender: CellRender;
+    renderTableParams: RenderTableParams<D>;
+} & {
+    onBlur?: ((...args: any[]) => any) | undefined;
+}, {}, {}, {}, {}, {}>;
 export default _default;

package/dist/packages/components/RenderItemSlots.d.ts

@@ -1,12 +1,25 @@
-declare const _default: import('vue').DefineSetupFnComponent<{
-    item: any;
-    formData: any;
-    passTrigger: any;
-    passDelayTrigger: any;
-}, {}, {}, {
-    item: any;
-    formData: any;
-    passTrigger: any;
-    passDelayTrigger: any;
-} & {}, import('vue').PublicProps>;
+import { PFormItemProps } from '../../declarations/antProxy';
+declare const _default: new <F extends Recordable = Recordable<any>>(props: {
+    formData: F;
+    item: PFormItemProps<F>;
+    passTrigger: (cusFields?: string | string[]) => void;
+    passDelayTrigger: (cusFields?: string | string[], time?: number) => void;
+} & {} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps) => import('vue').CreateComponentPublicInstanceWithMixins<{
+    formData: F;
+    item: PFormItemProps<F>;
+    passTrigger: (cusFields?: string | string[]) => void;
+    passDelayTrigger: (cusFields?: string | string[], time?: number) => void;
+} & {}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, {}, {}, string, {}, any, import('vue').ComponentProvideOptions, {
+    P: {};
+    B: {};
+    D: {};
+    C: {};
+    M: {};
+    Defaults: {};
+}, {
+    formData: F;
+    item: PFormItemProps<F>;
+    passTrigger: (cusFields?: string | string[]) => void;
+    passDelayTrigger: (cusFields?: string | string[], time?: number) => void;
+} & {}, {}, {}, {}, {}, {}>;
 export default _default;

package/dist/packages/components/RenderTitleSlots.d.ts

@@ -1,6 +1,16 @@
-declare const _default: import('vue').DefineSetupFnComponent<{
-    column: any;
-}, {}, {}, {
-    column: any;
-} & {}, import('vue').PublicProps>;
+import { ColumnProps } from '../../declarations/antProxy';
+declare const _default: new <D extends Recordable = Recordable<any>>(props: {
+    column: ColumnProps<D>;
+} & {} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps) => import('vue').CreateComponentPublicInstanceWithMixins<{
+    column: ColumnProps<D>;
+} & {}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, {}, {}, string, {}, any, import('vue').ComponentProvideOptions, {
+    P: {};
+    B: {};
+    D: {};
+    C: {};
+    M: {};
+    Defaults: {};
+}, {
+    column: ColumnProps<D>;
+} & {}, {}, {}, {}, {}, {}>;
 export default _default;

package/dist/packages/renders/TableInput.vue.d.ts

@@ -0,0 +1,25 @@
+import { TableProps } from 'ant-design-vue';
+import { ColumnProps } from '../../declarations/antProxy';
+declare const _default: <D extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{
+        tableConfig: TableProps<any>;
+        modelValue: D[];
+        editColumns: ColumnProps<Recordable<any>>[];
+    }> & Omit<{
+        readonly tableConfig: TableProps<any>;
+        readonly modelValue: D[];
+        readonly editColumns: ColumnProps<Recordable<any>>[];
+        readonly onTrigger?: ((...args: any[]) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "tableConfig" | "modelValue" | "editColumns">, "onTrigger" | "onUpdate:modelValue" | ("tableConfig" | "modelValue" | "editColumns")> & {} & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (event: "trigger" | "update:modelValue", ...args: any[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/packages/utils/config.d.ts

@@ -1,5 +1,6 @@
 import { PFormProps, PGridProps } from '../../declarations/antProxy';
 import { ConfigType } from 'e-virt-table';
+import { VNode } from 'vue';
 export interface UIKitConfig {
     form?: {
         labelCol?: any;
@@ -13,8 +14,15 @@ export interface UIKitConfig {
         striped?: boolean;
     };
     canvasTable?: ConfigType;
+    /**
+     * 自定义 tooltip 渲染函数，替换全局所有 a-tooltip。
+     * @param defaultSlot 原 tooltip 触发元素（图标等）
+     * @param content tooltip 内容，字符串或返回 VNode 的函数
+     */
+    renderTooltip?: (defaultSlot: () => VNode, content: string | (() => VNode)) => VNode;
 }
 export declare function setUIKitConfig(config: Partial<UIKitConfig>): void;
+export declare function getTooltipRenderer(): UIKitConfig['renderTooltip'];
 export declare function getUIKitConfig(): UIKitConfig;
 export declare function getFormDefaults(): Partial<PFormProps>;
 export declare function getGridDefaults(): Partial<PGridProps>;