cosey 0.7.4 → 0.7.6

package/components/svga-card/svga-card.d.ts

@@ -21,7 +21,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: StringConstructor;
     };
     type: {
-        type: import("vue").PropType<"image" | "video" | "audio" | (string & {})>;
+        type: import("vue").PropType<"image" | "video" | "audio" | "svga" | (string & {})>;
     };
     title: {
         type: StringConstructor;
@@ -55,7 +55,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: StringConstructor;
     };
     type: {
-        type: import("vue").PropType<"image" | "video" | "audio" | (string & {})>;
+        type: import("vue").PropType<"image" | "video" | "audio" | "svga" | (string & {})>;
     };
     title: {
         type: StringConstructor;

package/components/table/index.d.ts

@@ -1,6 +1,6 @@
 export * from './table';
 export * from './table-column/table-column.api';
-export * from './table-query/table-query';
+export * from './table-query/table-query.api';
 export * from './useTable';
 declare const _Table: {
     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
@@ -187,7 +187,7 @@ declare const _Table: {
             type: import("vue").PropType<import("./table").TableConfig["keys"]>;
         };
         statsColumns: {
-            type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats").TableStatisticsColumn[]>>;
+            type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats.api").TableStatisticsColumn[]>>;
         };
         statsData: {
             type: import("vue").MaybeRef<any>;
@@ -533,7 +533,7 @@ declare const _Table: {
             type: import("vue").PropType<import("./table").TableConfig["keys"]>;
         };
         statsColumns: {
-            type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats").TableStatisticsColumn[]>>;
+            type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats.api").TableStatisticsColumn[]>>;
         };
         statsData: {
             type: import("vue").MaybeRef<any>;
@@ -734,7 +734,7 @@ declare const _Table: {
         type: import("vue").PropType<import("./table").TableConfig["keys"]>;
     };
     statsColumns: {
-        type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats").TableStatisticsColumn[]>>;
+        type: import("vue").PropType<import("vue").MaybeRef<import("./table-stats/table-stats.api").TableStatisticsColumn[]>>;
     };
     statsData: {
         type: import("vue").MaybeRef<any>;

package/components/table/index.js

@@ -2,7 +2,7 @@ import { withInstall } from '../utils.js';
 import stdin_default$1 from './table.vue.js';
 export { defaultTableConfig, elSlotsName, omittedTableProps, tableEmitEvents, tableEmitOnEvents, tableEmitOnProps, tableExposeKeys, tableProps } from './table.js';
 export { tableColumnProps } from './table-column/table-column.api.js';
-export { createScheme, omittedTableQueryProps, tableQueryExposeKeys, tableQueryProps } from './table-query/table-query.js';
+export { createScheme, omittedTableQueryProps, tableQueryEmits, tableQueryExposeKeys, tableQueryProps, tableQuerySlots } from './table-query/table-query.api.js';
 export { useTable } from './useTable.js';
 
 const _Table = withInstall(stdin_default$1);

package/components/table/table-column/renderer.js

@@ -123,7 +123,7 @@ function renderer({
           column
         })
       }), {
-        default: () => [obj.format ? obj.format(cellValue, row, column, index) : cellValue, cellValue]
+        default: () => [obj.format ? obj.format(cellValue, row, column, index) : cellValue]
       });
   }
 }

package/components/table/table-column/table-column.d.ts

@@ -24,7 +24,7 @@ declare const TableColumn: import("vue").DefineComponent<{
     resizable?: boolean | undefined;
     columnKey?: string | undefined;
     headerAlign?: string | undefined;
-    showOverflowTooltip?: boolean | Partial<Pick<import("element-plus/es/components/index.mjs").ElTooltipProps, "offset" | "transition" | "enterable" | "appendTo" | "placement" | "popperClass" | "showAfter" | "showArrow" | "effect" | "popperOptions" | "hideAfter">> | undefined;
+    showOverflowTooltip?: boolean | Partial<Pick<import("element-plus/es/components/index.mjs").ElTooltipProps, "offset" | "transition" | "enterable" | "appendTo" | "placement" | "popperClass" | "showArrow" | "effect" | "popperOptions" | "showAfter" | "hideAfter">> | undefined;
     selectable?: ((row: any, index: number) => boolean) | undefined;
     reserveSelection?: boolean | undefined;
     filterMethod?: import("element-plus/es/components/table/src/table-column/defaults.mjs").FilterMethods<any> | undefined;
@@ -68,7 +68,7 @@ declare const TableColumn: import("vue").DefineComponent<{
     resizable?: boolean | undefined;
     columnKey?: string | undefined;
     headerAlign?: string | undefined;
-    showOverflowTooltip?: boolean | Partial<Pick<import("element-plus/es/components/index.mjs").ElTooltipProps, "offset" | "transition" | "enterable" | "appendTo" | "placement" | "popperClass" | "showAfter" | "showArrow" | "effect" | "popperOptions" | "hideAfter">> | undefined;
+    showOverflowTooltip?: boolean | Partial<Pick<import("element-plus/es/components/index.mjs").ElTooltipProps, "offset" | "transition" | "enterable" | "appendTo" | "placement" | "popperClass" | "showArrow" | "effect" | "popperOptions" | "showAfter" | "hideAfter">> | undefined;
     selectable?: ((row: any, index: number) => boolean) | undefined;
     reserveSelection?: boolean | undefined;
     filterMethod?: import("element-plus/es/components/table/src/table-column/defaults.mjs").FilterMethods<any> | undefined;
@@ -95,7 +95,7 @@ declare const TableColumn: import("vue").DefineComponent<{
     align: "left" | "right" | "center" | undefined;
     sortable: string | boolean;
     resizable: boolean;
-    showOverflowTooltip: boolean | Partial<Pick<import("element-plus/es/components/index.mjs").ElTooltipProps, "offset" | "transition" | "enterable" | "appendTo" | "placement" | "popperClass" | "showAfter" | "showArrow" | "effect" | "popperOptions" | "hideAfter">> | undefined;
+    showOverflowTooltip: boolean | Partial<Pick<import("element-plus/es/components/index.mjs").ElTooltipProps, "offset" | "transition" | "enterable" | "appendTo" | "placement" | "popperClass" | "showArrow" | "effect" | "popperOptions" | "showAfter" | "hideAfter">> | undefined;
     reserveSelection: boolean;
     filterMultiple: boolean;
     sortOrders: (import("element-plus/es/components/table/src/table/defaults.mjs").TableSortOrder | null)[];

package/components/table/table-column-editor/table-column-editor.api.d.ts

@@ -0,0 +1,17 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { TableColumnProps } from '../table-column/table-column.api';
+export declare const tableColumnEditorProps: {
+    modelValue: {
+        type: PropType<TableColumnProps[]>;
+        default: () => never[];
+    };
+    virtualRef: {
+        type: null;
+    };
+};
+export type TableColumnEditorProps = ExtractPropTypes<typeof tableColumnEditorProps>;
+export declare const tableColumnEditorEmits: {
+    'update:modelValue': (value: TableColumnProps[]) => boolean;
+    reset: () => boolean;
+};
+export type TableColumnEditorEmits = typeof tableColumnEditorEmits;

package/components/table/table-column-editor/table-column-editor.api.js

@@ -0,0 +1,15 @@
+const tableColumnEditorProps = {
+  modelValue: {
+    type: Array,
+    default: () => []
+  },
+  virtualRef: {
+    type: null
+  }
+};
+const tableColumnEditorEmits = {
+  "update:modelValue": (value) => Array.isArray(value),
+  reset: () => true
+};
+
+export { tableColumnEditorEmits, tableColumnEditorProps };

package/components/table/table-column-editor/table-column-editor.d.ts

@@ -1,12 +1,27 @@
 import { type TableColumnProps } from '../table-column/table-column.api';
-export interface TableColumnEditorProps {
-    modelValue?: TableColumnProps[];
-    virtualRef?: any;
-}
-export declare const defaultTableColumnEditorProps: {
-    modelValue: () => never[];
-};
-export interface TableColumnEditorEmits {
-    (e: 'update:modelValue', value: TableColumnProps[]): void;
-    (e: 'reset'): void;
-}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: import("vue").PropType<TableColumnProps[]>;
+        default: () => never[];
+    };
+    virtualRef: {
+        type: null;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:modelValue': (value: TableColumnProps[]) => boolean;
+    reset: () => boolean;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: import("vue").PropType<TableColumnProps[]>;
+        default: () => never[];
+    };
+    virtualRef: {
+        type: null;
+    };
+}>> & Readonly<{
+    onReset?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: TableColumnProps[]) => any) | undefined;
+}>, {
+    modelValue: TableColumnProps[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/table/table-column-editor/table-column-editor.js

@@ -1,5 +1,155 @@
-const defaultTableColumnEditorProps = {
-  modelValue: () => []
-};
+import { defineComponent, useTemplateRef, ref, createVNode, mergeProps, shallowReactive, nextTick, isVNode } from 'vue';
+import { tableColumnEditorEmits, tableColumnEditorProps } from './table-column-editor.api.js';
+import stdin_default$2 from './list.vue.js';
+import stdin_default$1 from './table-column-editor.style.js';
+import { ElPopover, ElCheckbox, ElScrollbar, ElButton } from 'element-plus';
+import { useComponentConfig } from '../../config-provider/config-provider.api.js';
+import { useLocale } from '../../../hooks/useLocale.js';
+import { useTreeCheck } from '../../../hooks/useTreeCheck.js';
+import { mapTree, walkTree } from '../../../utils/tree.js';
 
-export { defaultTableColumnEditorProps };
+function _isSlot(s) {
+  return typeof s === 'function' || Object.prototype.toString.call(s) === '[object Object]' && !isVNode(s);
+}
+var stdin_default = defineComponent({
+  name: "CoTableColumnEditor",
+  props: tableColumnEditorProps,
+  emits: tableColumnEditorEmits,
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const {
+      prefixCls
+    } = useComponentConfig("table-column-editor");
+    const {
+      t
+    } = useLocale();
+    const {
+      hashId
+    } = stdin_default$1(prefixCls);
+    const wrapperRef = useTemplateRef("wrapper");
+    const visible = ref(false);
+    const maxHeight = ref("");
+    const {
+      tree,
+      checkAllValue,
+      checkAllIndeterminate,
+      onCheckAllChange,
+      initialize,
+      setCheckedByNode
+    } = useTreeCheck({
+      childrenKey: "columns",
+      initialChecked: true
+    });
+    const setUncheckedIfHiden = () => {
+      walkTree(tree.value, "children", node => {
+        const hidden = !!node.data.hidden;
+        if (hidden) {
+          setCheckedByNode(node, false);
+        }
+      });
+    };
+    const onBeforeEnter = () => {
+      initialize(mapTree(props.modelValue, node => {
+        return shallowReactive({
+          ...node
+        });
+      }, {
+        childrenKey: "columns"
+      }));
+      setUncheckedIfHiden();
+      nextTick(() => {
+        const el = wrapperRef.value;
+        if (el) {
+          const top = el.getBoundingClientRect().top;
+          maxHeight.value = `calc(100vh - ${top}px - 68px - 10px)`;
+        }
+      });
+    };
+    const getUpdatedColumns = () => {
+      return mapTree(tree.value, node => {
+        return {
+          ...node.data,
+          hidden: node.checkedStatus === "unchecked"
+        };
+      }, {
+        childrenKey: "children",
+        newChildrenKey: "columns"
+      });
+    };
+    const confirm = () => {
+      emit("update:modelValue", getUpdatedColumns());
+      visible.value = false;
+    };
+    const cancel = () => {
+      visible.value = false;
+    };
+    const reset = () => {
+      emit("reset");
+      visible.value = false;
+    };
+    return () => {
+      return createVNode(ElPopover, mergeProps(props, {
+        "visible": visible.value,
+        "onUpdate:visible": $event => visible.value = $event,
+        "virtual-triggering": true,
+        "placement": "bottom",
+        "width": 240,
+        "trigger": "click",
+        "popperStyle": "--el-popover-padding: 0; --el-checkbox-height: auto",
+        "onBefore-enter": onBeforeEnter
+      }), {
+        default: () => {
+          let _slot, _slot2, _slot3, _slot4;
+          return createVNode("div", {
+            "ref": "wrapper",
+            "class": [hashId.value, prefixCls.value]
+          }, [createVNode("div", {
+            "class": `${prefixCls.value}-header`
+          }, [createVNode(ElCheckbox, {
+            "modelValue": checkAllValue.value,
+            "indeterminate": checkAllIndeterminate.value,
+            "onChange": onCheckAllChange
+          }, _isSlot(_slot = t("co.common.checkAll")) ? _slot : {
+            default: () => [_slot]
+          })]), createVNode(ElScrollbar, {
+            "maxHeight": maxHeight.value
+          }, {
+            default: () => [createVNode("div", {
+              "class": `${prefixCls.value}-body`
+            }, [createVNode(stdin_default$2, {
+              "nodeList": tree.value
+            }, null)])]
+          }), createVNode("div", {
+            "class": `${prefixCls.value}-footer`
+          }, [createVNode(ElButton, {
+            "size": "small",
+            "link": true,
+            "onClick": reset
+          }, _isSlot(_slot2 = t("co.table.restoreDefault")) ? _slot2 : {
+            default: () => [_slot2]
+          }), createVNode("div", {
+            "style": "margin-inline-start: auto"
+          }, [createVNode(ElButton, {
+            "size": "small",
+            "link": true,
+            "onClick": cancel
+          }, _isSlot(_slot3 = t("co.common.cancel")) ? _slot3 : {
+            default: () => [_slot3]
+          }), createVNode(ElButton, {
+            "size": "small",
+            "link": true,
+            "type": "primary",
+            "onClick": confirm
+          }, _isSlot(_slot4 = t("co.common.confirm")) ? _slot4 : {
+            default: () => [_slot4]
+          })])])]);
+        },
+        reference: () => slots.default?.({})
+      });
+    };
+  }
+});
+
+export { stdin_default as default };

package/components/table/table-export/item.d.ts

@@ -0,0 +1,15 @@
+import { type TableColumnProps } from '../table-column/table-column.api';
+import { type CheckableNode } from '../../../hooks';
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<CheckableNode<TableColumnProps>>;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<CheckableNode<TableColumnProps>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/table/table-export/item.js

@@ -0,0 +1,37 @@
+import { defineComponent, computed, createVNode } from 'vue';
+import stdin_default$1 from './list.js';
+import { ElCheckbox } from 'element-plus';
+import { useTreeCheckInject } from '../../../hooks/useTreeCheck.js';
+import { useComponentConfig } from '../../config-provider/config-provider.api.js';
+
+var stdin_default = defineComponent({
+  props: {
+    node: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props) {
+    const column = computed(() => props.node.data);
+    const {
+      onCheckChange
+    } = useTreeCheckInject();
+    const {
+      prefixCls
+    } = useComponentConfig("table-export");
+    return () => {
+      return createVNode("div", null, [createVNode("div", {
+        "class": `${prefixCls.value}-list-item`
+      }, [createVNode(ElCheckbox, {
+        "label": column.value.label,
+        "modelValue": props.node.checkedStatus === "checked",
+        "indeterminate": props.node.checkedStatus === "indeterminate",
+        "onChange": $event => onCheckChange($event, props.node)
+      }, null)]), props.node.children && props.node.children.length && createVNode(stdin_default$1, {
+        "nodeList": props.node.children
+      }, null)]);
+    };
+  }
+});
+
+export { stdin_default as default };

package/components/table/table-export/list.d.ts

@@ -0,0 +1,15 @@
+import { PropType } from 'vue';
+import { type TableColumnProps } from '../table-column/table-column.api';
+import { type CheckableNode } from '../../../hooks';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    nodeList: {
+        type: PropType<CheckableNode<TableColumnProps>[]>;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    nodeList: {
+        type: PropType<CheckableNode<TableColumnProps>[]>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/table/table-export/list.js

@@ -0,0 +1,27 @@
+import { defineComponent, createVNode } from 'vue';
+import stdin_default$1 from './item.js';
+import { useComponentConfig } from '../../config-provider/config-provider.api.js';
+
+var stdin_default = defineComponent({
+  props: {
+    nodeList: {
+      type: Array,
+      required: true
+    }
+  },
+  setup(props) {
+    const {
+      prefixCls
+    } = useComponentConfig("table-export");
+    return () => {
+      return createVNode("div", {
+        "class": `${prefixCls.value}-list`
+      }, [props.nodeList.map((node, i) => createVNode(stdin_default$1, {
+        "node": node,
+        "key": i
+      }, null))]);
+    };
+  }
+});
+
+export { stdin_default as default };

package/components/table/table-export/table-export.api.d.ts

@@ -0,0 +1,208 @@
+import { type TableColumnProps } from '../table-column/table-column.api';
+import { type ExtractPropTypes, type PropType } from 'vue';
+export declare const tableExportProps: {
+    columns: {
+        type: PropType<TableColumnProps[]>;
+        default: () => never[];
+    };
+    data: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    config: {
+        type: PropType<boolean | {
+            filename: string;
+        }>;
+    };
+    footerCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    width: {
+        type: PropType<import("../..").FormDialogWidth>;
+        default: string;
+    };
+    closeOnClickModal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnPressEscape: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    confirmText: {
+        type: StringConstructor;
+        default: string;
+    };
+    cancelText: {
+        type: StringConstructor;
+        default: string;
+    };
+    confirmProps: {
+        type: PropType<import("element-plus").ButtonProps>;
+    };
+    cancelProps: {
+        type: PropType<import("element-plus").ButtonProps>;
+    };
+    hideConfirm: {
+        type: BooleanConstructor;
+    };
+    hideCancel: {
+        type: BooleanConstructor;
+    };
+    appendToBody: BooleanConstructor;
+    appendTo: {
+        readonly type: PropType<string | HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "body";
+    };
+    beforeClose: {
+        readonly type: PropType<import("element-plus").DialogBeforeCloseFn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    destroyOnClose: BooleanConstructor;
+    lockScroll: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    modal: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    modalPenetrable: BooleanConstructor;
+    openDelay: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 0;
+    };
+    closeDelay: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 0;
+    };
+    top: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    modelValue: BooleanConstructor;
+    modalClass: StringConstructor;
+    headerClass: StringConstructor;
+    bodyClass: StringConstructor;
+    footerClass: StringConstructor;
+    zIndex: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    trapFocus: BooleanConstructor;
+    headerAriaLevel: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "2";
+    };
+    transition: {
+        readonly type: PropType<import("element-plus").DialogTransition>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    center: BooleanConstructor;
+    alignCenter: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    closeIcon: {
+        readonly type: PropType<string | import("vue").Component>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    draggable: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    overflow: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    fullscreen: BooleanConstructor;
+    showClose: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    title: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    ariaLevel: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "2";
+    };
+};
+export declare const omittedTableExportProps: keyof typeof tableExportProps;
+export type TableExportProps = ExtractPropTypes<typeof tableExportProps>;
+export declare const tableExportEmits: {
+    open: () => boolean;
+    opened: () => boolean;
+    close: () => boolean;
+    closed: () => boolean;
+    "update:modelValue": (value: boolean) => boolean;
+    openAutoFocus: () => boolean;
+    closeAutoFocus: () => boolean;
+};
+export type TableExportEmits = typeof tableExportEmits;
+export interface TableExportContext {
+    setCheckedByColumn: (column: TableColumnProps, checked: boolean) => void;
+}
+export declare const tableExportContextSymbol: unique symbol;