ax-libs 0.0.1

package/dist/ui/modal/components/form-modal/index.d.ts

@@ -0,0 +1,98 @@
+import { default as modal } from './form-modal.vue';
+import { ComponentExposed } from 'vue-component-type-helpers';
+export * from './props';
+export declare const AxFormModal: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: ((evt: "change", data: T) => void) & ((evt: "update:open", data: boolean) => void) & ((evt: "confirm", data: T) => void);
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & {
+        size?: "" | "default" | "small" | "large" | undefined;
+        title?: string | undefined;
+        appendTo?: (string | HTMLElement) | undefined;
+        top?: string | undefined;
+        transition?: import('element-plus').DialogTransition | undefined;
+        direction?: "ltr" | "rtl" | "ttb" | "btt" | undefined;
+        resizable?: boolean | undefined;
+        withHeader?: boolean | undefined;
+        modalFade?: boolean | undefined;
+        headerAriaLevel?: string | undefined;
+        appendToBody?: boolean | undefined;
+        beforeClose?: import('element-plus').DialogBeforeCloseFn | undefined;
+        destroyOnClose?: boolean | undefined;
+        closeOnClickModal?: boolean | undefined;
+        closeOnPressEscape?: boolean | undefined;
+        lockScroll?: boolean | undefined;
+        modal?: boolean | undefined;
+        modalPenetrable?: boolean | undefined;
+        openDelay?: number | undefined;
+        closeDelay?: number | undefined;
+        modalClass?: string | undefined;
+        width?: string | number | undefined;
+        zIndex?: number | undefined;
+        trapFocus?: boolean | undefined;
+        center?: boolean | undefined;
+        alignCenter?: boolean | undefined;
+        closeIcon?: import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined;
+        draggable?: boolean | undefined;
+        overflow?: boolean | undefined;
+        fullscreen?: boolean | undefined;
+        headerClass?: string | undefined;
+        bodyClass?: string | undefined;
+        footerClass?: string | undefined;
+        showClose?: boolean | undefined;
+        ariaLevel?: string | undefined;
+        disabled?: boolean | undefined;
+        loading?: boolean | undefined;
+        rules?: import('element-plus').FormRules | undefined;
+        labelPosition?: "left" | "right" | "top" | undefined;
+        requireAsteriskPosition?: "left" | "right" | undefined;
+        labelWidth?: string | number | undefined;
+        labelSuffix?: string | undefined;
+        inline?: boolean | undefined;
+        inlineMessage?: boolean | undefined;
+        statusIcon?: boolean | undefined;
+        showMessage?: boolean | undefined;
+        validateOnRuleChange?: boolean | undefined;
+        hideRequiredAsterisk?: boolean | undefined;
+        scrollToError?: boolean | undefined;
+        scrollIntoViewOptions?: (ScrollIntoViewOptions | boolean) | undefined;
+        submitButton?: import('../../..').AxButtonProps | undefined;
+        type?: "dialog" | "drawer" | undefined;
+        open?: boolean | undefined;
+        okConfig?: import('../../..').AxButtonProps | undefined;
+        cancelConfig?: import('../../..').AxButtonProps | undefined;
+        footer?: boolean | undefined;
+        onChange?: ((data: T) => any) | undefined;
+        "onUpdate:open"?: ((data: boolean) => any) | undefined;
+        onConfirm?: ((data: T) => any) | undefined;
+    } & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        getValues: () => T;
+        getFlForm: () => import('element-plus').FormInstance | undefined;
+        getFields: () => (keyof T)[];
+        getDefaultValues: () => {} & Record<string, any>;
+        setValues: (data: Partial<T>) => void;
+        resetValues: () => void;
+        clearValues: () => void;
+        getModal: () => import('element-plus').DrawerInstance | undefined;
+        close: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+    emit: ((evt: "change", data: T) => void) & ((evt: "update:open", data: boolean) => void) & ((evt: "confirm", data: T) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export type AxFormModalInstance = ComponentExposed<typeof modal>;
+export default AxFormModal;

package/dist/ui/modal/components/form-modal/props.d.ts

@@ -0,0 +1,25 @@
+import { DrawerProps, DrawerEmits } from 'element-plus';
+import { AxButtonOptions, AxButtonProps } from '../../../button';
+import { EmitsToProps } from '../../../../utils';
+import { EmitsToProps as VueProps } from 'vue';
+import { FieldsConfig } from '../../../../hooks/common/useComponentPool.ts';
+import { AxFormItemOptions, AxFormProps } from '../../../form';
+import { FetchOptions, RequestFetch } from '../../../../hooks';
+export type AxFormModalProps = Omit<DrawerProps, 'modelValue'> & Omit<AxFormProps, 'isDefault'> & {
+    type?: 'dialog' | 'drawer';
+    open?: boolean;
+    okConfig?: AxButtonProps;
+    cancelConfig?: AxButtonProps;
+    footer?: boolean;
+};
+export interface AxFormModalEmits<T> {
+    "update:open": [data: boolean];
+    'confirm': [data: T];
+    'change': [data: T];
+}
+export interface AxFormModalOptions<T extends Record<string, any>, R = any> extends AxFormModalProps, EmitsToProps<AxFormModalEmits<T>>, VueProps<DrawerEmits> {
+    buttonConfig?: FieldsConfig<AxButtonOptions>;
+    fieldsConfig?: FieldsConfig<AxFormItemOptions<T>>;
+    apiConfig?: FetchOptions<T, R>;
+    api?: RequestFetch<T, R>;
+}

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

@@ -0,0 +1,47 @@
+import { default as modal } from './modal.vue';
+export * from './props';
+export declare const AxModal: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./props').AxModalProps> & Readonly<{
+        "onUpdate:open"?: ((data: boolean) => any) | undefined;
+        onConfirm?: ((data?: void | undefined) => any) | undefined;
+    }>, {
+        getModal: () => import('element-plus').DrawerInstance | undefined;
+        close: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:open": (data: boolean) => any;
+        confirm: (data: void) => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./props').AxModalProps> & Readonly<{
+        "onUpdate:open"?: ((data: boolean) => any) | undefined;
+        onConfirm?: ((data?: void | undefined) => any) | undefined;
+    }>, {
+        getModal: () => import('element-plus').DrawerInstance | undefined;
+        close: () => void;
+    }, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./props').AxModalProps> & Readonly<{
+    "onUpdate:open"?: ((data: boolean) => any) | undefined;
+    onConfirm?: ((data?: void | undefined) => any) | undefined;
+}>, {
+    getModal: () => import('element-plus').DrawerInstance | undefined;
+    close: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (data: boolean) => any;
+    confirm: (data: void) => any;
+}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+});
+export type AxModalInstance = InstanceType<typeof modal>;
+export default AxModal;

package/dist/ui/modal/components/modal/modal.vue.d.ts

@@ -0,0 +1,26 @@
+import { DrawerInstance } from 'element-plus';
+import { AxModalProps } from './props';
+declare var __VLS_23: {}, __VLS_40: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_23) => any;
+} & {
+    footer?: (props: typeof __VLS_40) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<AxModalProps, {
+    getModal: () => DrawerInstance | undefined;
+    close: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (data: boolean) => any;
+    confirm: (data: void) => any;
+}, string, import('vue').PublicProps, Readonly<AxModalProps> & Readonly<{
+    "onUpdate:open"?: ((data: boolean) => any) | undefined;
+    onConfirm?: ((data?: void | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/ui/modal/components/modal/props.d.ts

@@ -0,0 +1,20 @@
+import { DrawerProps, DrawerEmits } from 'element-plus';
+import { AxButtonOptions, AxButtonProps } from '../../../button';
+import { EmitsToProps } from '../../../../utils';
+import { EmitsToProps as VueProps } from 'vue';
+import { FieldsConfig } from '../../../../hooks/common/useComponentPool.ts';
+export interface AxModalProps extends Omit<DrawerProps, 'modelValue'> {
+    type?: 'dialog' | 'drawer';
+    open?: boolean;
+    okConfig?: AxButtonProps;
+    cancelConfig?: AxButtonProps;
+    footer?: boolean;
+}
+export interface AxModalEmits {
+    "update:open": [data: boolean];
+    'confirm': [data: void];
+}
+export interface AxModalOptions extends AxModalProps, EmitsToProps<AxModalEmits>, VueProps<DrawerEmits> {
+    buttonConfig?: FieldsConfig<AxButtonOptions>;
+    slot?: any;
+}

package/dist/ui/modal/index.d.ts

@@ -0,0 +1,3 @@
+export * from './components/modal';
+export * from './components/form-modal';
+export * from './util';

package/dist/ui/modal/util/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ui/table/components/table/index.d.ts

@@ -0,0 +1,105 @@
+import { default as table } from './table.vue';
+import { ComponentExposed } from 'vue-component-type-helpers';
+export * from './props';
+export declare const AxTable: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: {};
+    slots: {
+        search?: (props: {}) => any;
+    } & {
+        tool?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & {
+        dataSource?: T[] | undefined;
+        api?: import('../../../..').RequestFetch<any, import('../../../..').PageData<T> | T[]> | undefined;
+        apiConfig?: import('../../../..').FetchOptions<any, import('../../../..').PageData<T> | T[]> | undefined;
+        data?: T[] | undefined;
+        size?: import('element-plus').ComponentSize | undefined;
+        width?: string | number | undefined;
+        height?: string | number | undefined;
+        maxHeight?: string | number | undefined;
+        fit?: boolean | undefined;
+        stripe?: boolean | undefined;
+        border?: boolean | undefined;
+        rowKey?: string | ((row: T) => string) | undefined;
+        context?: import('element-plus').Table<T> | undefined;
+        showHeader?: boolean | undefined;
+        showSummary?: boolean | undefined;
+        sumText?: string | undefined;
+        summaryMethod?: import('element-plus').SummaryMethod<T> | undefined;
+        rowClassName?: import('element-plus').ColumnCls<T> | undefined;
+        rowStyle?: import('element-plus').ColumnStyle<T> | undefined;
+        cellClassName?: import('element-plus').CellCls<T> | undefined;
+        cellStyle?: import('element-plus').CellStyle<T> | undefined;
+        headerRowClassName?: import('element-plus').ColumnCls<T> | undefined;
+        headerRowStyle?: import('element-plus').ColumnStyle<T> | undefined;
+        headerCellClassName?: import('element-plus').CellCls<T> | undefined;
+        headerCellStyle?: import('element-plus').CellStyle<T> | undefined;
+        highlightCurrentRow?: boolean | undefined;
+        currentRowKey?: string | number | undefined;
+        emptyText?: string | undefined;
+        expandRowKeys?: Array<string> | undefined;
+        defaultExpandAll?: boolean | undefined;
+        rowExpandable?: ((row: T, index: number) => boolean) | undefined;
+        defaultSort?: import('element-plus').Sort | undefined;
+        tooltipEffect?: string | undefined;
+        tooltipOptions?: import('element-plus/es/components/table/src/util.mjs').TableOverflowTooltipOptions | undefined;
+        spanMethod?: ((data: {
+            row: T;
+            rowIndex: number;
+            column: import('element-plus').TableColumnCtx<T>;
+            columnIndex: number;
+        }) => number[] | {
+            rowspan: number;
+            colspan: number;
+        } | undefined) | undefined;
+        selectOnIndeterminate?: boolean | undefined;
+        indent?: number | undefined;
+        treeProps?: import('element-plus/es/components/table/src/table/defaults.mjs').TreeProps | undefined;
+        lazy?: boolean | undefined;
+        load?: ((row: T, treeNode: import('element-plus').TreeNode, resolve: (data: T[]) => void) => void) | undefined;
+        className?: string | undefined;
+        style?: import('vue').StyleValue;
+        tableLayout?: ("fixed" | "auto") | undefined;
+        scrollbarAlwaysOn?: boolean | undefined;
+        flexible?: boolean | undefined;
+        showOverflowTooltip?: (boolean | import('element-plus/es/components/table/src/util.mjs').TableOverflowTooltipOptions) | undefined;
+        tooltipFormatter?: import('element-plus/es/components/table/src/util.mjs').TableOverflowTooltipFormatter<T> | undefined;
+        appendFilterPanelTo?: string | undefined;
+        scrollbarTabindex?: number | string | undefined;
+        nativeScrollbar?: boolean | undefined;
+    } & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        getElTable: () => import('element-plus').TableInstance | undefined;
+        setConfig: import('../../../..').StateApi<import('../../../..').FetchOptions<any, import('../../../..').PageData<T> | T[]>>;
+        setApi: import('../../../..').StateApi<import('../../../..').RequestFetch<any, import('../../../..').PageData<T> | T[]>>;
+        load: (params?: any) => Promise<any>;
+        getConfig: () => import('../../../..').FetchOptions<any, import('../../../..').PageData<T> | T[]>;
+        get: () => any;
+        getReady: () => boolean;
+        setParams: (data: any, load?: boolean) => void;
+        reload: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        search?: (props: {}) => any;
+    } & {
+        tool?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export type AxTableInstance = ComponentExposed<typeof table>;
+export default AxTable;

package/dist/ui/table/components/table/props.d.ts

@@ -0,0 +1,36 @@
+import { TableProps } from 'element-plus';
+import { FetchOptions, RequestFetch } from '../../../../hooks';
+import { PageData } from '../../../../utils';
+import { FieldsConfig } from '../../../../hooks/common/useComponentPool.ts';
+import { AxTableColumnProps, AxTablePageProps, AxTableSelectOptions } from '../..';
+import { AxButtonOptions } from '../../../button';
+export interface AxTableProps<T extends Record<string, any> = any> extends Partial<TableProps<T>> {
+    dataSource?: T[];
+    api?: RequestFetch<any, T[] | PageData<T>>;
+    apiConfig?: FetchOptions<any, T[] | PageData<T>>;
+}
+export type AxTableOptions<T extends Record<string, any> = any> = Partial<AxTableProps<T>> & {
+    columnsConfig?: FieldsConfig<AxTableColumnProps>;
+    pageConfig?: AxTablePageProps;
+    searchForm?: AxTableSelectOptions<T>;
+    toolConfig?: FieldsConfig<AxButtonOptions>;
+    onScroll?: ((...args: T[]) => any) | undefined;
+    onSelect?: ((...args: T[]) => any) | undefined;
+    "onExpand-change"?: ((...args: T[]) => any) | undefined;
+    "onCurrent-change"?: ((...args: T[]) => any) | undefined;
+    "onSelect-all"?: ((...args: T[]) => any) | undefined;
+    "onSelection-change"?: ((...args: T[]) => any) | undefined;
+    "onCell-mouse-enter"?: ((...args: T[]) => any) | undefined;
+    "onCell-mouse-leave"?: ((...args: T[]) => any) | undefined;
+    "onCell-contextmenu"?: ((...args: T[]) => any) | undefined;
+    "onCell-click"?: ((...args: T[]) => any) | undefined;
+    "onCell-dblclick"?: ((...args: T[]) => any) | undefined;
+    "onRow-click"?: ((...args: T[]) => any) | undefined;
+    "onRow-contextmenu"?: ((...args: T[]) => any) | undefined;
+    "onRow-dblclick"?: ((...args: T[]) => any) | undefined;
+    "onHeader-click"?: ((...args: T[]) => any) | undefined;
+    "onHeader-contextmenu"?: ((...args: any[]) => any) | undefined;
+    "onSort-change"?: ((...args: T[]) => any) | undefined;
+    "onFilter-change"?: ((...args: T[]) => any) | undefined;
+    "onHeader-dragend"?: ((...args: T[]) => any) | undefined;
+};

package/dist/ui/table/components/table/table.vue.d.ts

@@ -0,0 +1,39 @@
+import { TableInstance } from 'element-plus';
+import { AxTableProps } from '../..';
+import { PageData } from '../../../../utils';
+declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AxTableProps<T>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        getElTable: () => TableInstance | undefined;
+        setConfig: import('../../../../hooks').StateApi<import('../../../../hooks').FetchOptions<any, PageData<T> | T[]>>;
+        setApi: import('../../../../hooks').StateApi<import('../../../../hooks').RequestFetch<any, PageData<T> | T[]>>;
+        load: (params?: any) => Promise<any>;
+        getConfig: () => import('../../../../hooks').FetchOptions<any, PageData<T> | T[]>;
+        get: () => any;
+        getReady: () => boolean;
+        setParams: (data: any, load?: boolean) => void;
+        reload: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        search?: (props: {}) => any;
+    } & {
+        tool?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/ui/table/components/table-column/index.d.ts

@@ -0,0 +1,3 @@
+export * from './props';
+export declare const AxTableColumn: import('vue').DefineComponent<import('./props').AxTableColumnProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./props').AxTableColumnProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default AxTableColumn;

package/dist/ui/table/components/table-column/props.d.ts

@@ -0,0 +1,3 @@
+import { TableColumnCtx } from 'element-plus';
+export interface AxTableColumnProps extends Partial<TableColumnCtx> {
+}

package/dist/ui/table/components/table-column/table-column.vue.d.ts

@@ -0,0 +1,4 @@
+import { AxTableColumnProps } from './props';
+declare const __VLS_export: import('vue').DefineComponent<AxTableColumnProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AxTableColumnProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/ui/table/components/table-page/index.d.ts

@@ -0,0 +1,5 @@
+import { default as tablePage } from './table-page.vue';
+export * from './props';
+export declare const AxTablePage: import('vue').DefineComponent<import('./props').AxTablePageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./props').AxTablePageProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default AxTablePage;
+export type AxTablePageInstance = InstanceType<typeof tablePage>;

package/dist/ui/table/components/table-page/props.d.ts

@@ -0,0 +1,5 @@
+import { PaginationProps } from 'element-plus';
+export interface AxTablePageProps extends Partial<PaginationProps> {
+    parmaNo?: string;
+    parmaSize?: string;
+}

package/dist/ui/table/components/table-page/table-page.vue.d.ts

@@ -0,0 +1,4 @@
+import { AxTablePageProps } from './props';
+declare const __VLS_export: import('vue').DefineComponent<AxTablePageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AxTablePageProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/ui/table/components/table-select/index.d.ts

@@ -0,0 +1,69 @@
+import { default as tableSelect } from './table-select.vue';
+import { ComponentExposed } from 'vue-component-type-helpers';
+export * from './props';
+export declare const AxTableSelect: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: ((evt: "reset") => void) & ((evt: "search", data: T) => void) & ((evt: "change", data: T) => void);
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        buttons?: (props: {}) => any;
+    };
+}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & {
+        isReset?: boolean | undefined;
+        resetButton?: import('../../..').AxButtonProps | undefined;
+        over?: number | undefined;
+        isDefault?: boolean | undefined;
+        submitButton?: import('../../..').AxButtonProps | undefined;
+        loading?: boolean | undefined;
+        size?: import('element-plus').ComponentSize | undefined;
+        disabled?: boolean | undefined;
+        rules?: import('element-plus').FormRules | undefined;
+        labelPosition?: "left" | "right" | "top" | undefined;
+        requireAsteriskPosition?: "left" | "right" | undefined;
+        labelWidth?: string | number | undefined;
+        labelSuffix?: string | undefined;
+        inline?: boolean | undefined;
+        inlineMessage?: boolean | undefined;
+        statusIcon?: boolean | undefined;
+        showMessage?: boolean | undefined;
+        validateOnRuleChange?: boolean | undefined;
+        hideRequiredAsterisk?: boolean | undefined;
+        scrollToError?: boolean | undefined;
+        scrollIntoViewOptions?: (ScrollIntoViewOptions | boolean) | undefined;
+        onReset?: (() => any) | undefined;
+        onSearch?: ((data: T) => any) | undefined;
+        onChange?: ((data: T) => any) | undefined;
+    } & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        setConfig: import('../../../..').StateApi<import('../../../..').FetchOptions<T, any[] | import('../../../..').PageData<any>>>;
+        setApi: import('../../../..').StateApi<import('../../../..').RequestFetch<T, any[] | import('../../../..').PageData<any>>>;
+        load: (params?: T | undefined) => Promise<any>;
+        getConfig: () => import('../../../..').FetchOptions<T, any[] | import('../../../..').PageData<any>>;
+        get: () => any;
+        getReady: () => boolean;
+        setParams: (data: T, load?: boolean) => void;
+        reload: () => void;
+        getValues: () => T;
+        getFlForm: () => import('element-plus').FormInstance | undefined;
+        getFields: () => (keyof T)[];
+        getDefaultValues: () => {} & Record<string, any>;
+        setValues: (data: Partial<T>) => void;
+        resetValues: () => void;
+        clearValues: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        buttons?: (props: {}) => any;
+    };
+    emit: ((evt: "reset") => void) & ((evt: "search", data: T) => void) & ((evt: "change", data: T) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default AxTableSelect;
+export type AxTableSelectInstance = ComponentExposed<typeof tableSelect>;

package/dist/ui/table/components/table-select/props.d.ts

@@ -0,0 +1,18 @@
+import { AxFormItemOptions, AxFormProps } from '../../../form';
+import { AxButtonOptions, AxButtonProps } from '../../../button';
+import { EmitsToProps } from '../../../../utils';
+import { FieldsConfig } from '../../../../hooks/common/useComponentPool.ts';
+export interface AxTableSelectProps extends AxFormProps {
+    isReset?: boolean;
+    resetButton?: AxButtonProps;
+    over?: number;
+}
+export interface AxTableSelectEmits<T> {
+    search: [data: T];
+    change: [data: T];
+    reset: [];
+}
+export interface AxTableSelectOptions<T extends Record<string, any>> extends EmitsToProps<AxTableSelectEmits<T>>, AxTableSelectProps {
+    fieldsConfig?: FieldsConfig<AxFormItemOptions<T>>;
+    buttonsConfig?: FieldsConfig<AxButtonOptions>;
+}

package/dist/ui/table/components/table-select/table-select.vue.d.ts

@@ -0,0 +1,44 @@
+import { AxTableSelectProps } from './props';
+import { PageData } from '../../../../utils';
+declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AxTableSelectProps & {
+        onReset?: (() => any) | undefined;
+        onSearch?: ((data: T) => any) | undefined;
+        onChange?: ((data: T) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        setConfig: import('../../../../hooks').StateApi<import('../../../../hooks').FetchOptions<T, any[] | PageData<any>>>;
+        setApi: import('../../../../hooks').StateApi<import('../../../../hooks').RequestFetch<T, any[] | PageData<any>>>;
+        load: (params?: T | undefined) => Promise<any>;
+        getConfig: () => import('../../../../hooks').FetchOptions<T, any[] | PageData<any>>;
+        get: () => any;
+        getReady: () => boolean;
+        setParams: (data: T, load?: boolean) => void;
+        reload: () => void;
+        getValues: () => T;
+        getFlForm: () => import('element-plus').FormInstance | undefined;
+        getFields: () => (keyof T)[];
+        getDefaultValues: () => {} & Record<string, any>;
+        setValues: (data: Partial<T>) => void;
+        resetValues: () => void;
+        clearValues: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        buttons?: (props: {}) => any;
+    };
+    emit: ((evt: "reset") => void) & ((evt: "search", data: T) => void) & ((evt: "change", data: T) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/ui/table/index.d.ts

@@ -0,0 +1,4 @@
+export * from './components/table';
+export * from './components/table-page';
+export * from './components/table-select';
+export * from './components/table-column';

package/dist/ui/table/util/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/bus.d.ts

@@ -0,0 +1 @@
+export declare const bus: import('mitt').Emitter<Record<import('mitt').EventType, unknown>>;

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './bus';
+export * from './type';
+export * from './object';
+export * from './ui';
+export * from './request';

package/dist/utils/object.d.ts

@@ -0,0 +1,16 @@
+import { DeepPartial } from 'ts-essentials';
+/**
+ * 深度合并两个对象的值,不同的值会追加,不会覆盖
+ * @template T 状态数据的类型
+ * @Param {T} object -需要被合并的对象
+ * @Param {DeepPartial<T>} source - 追加合并的对象
+ * @param bool
+ * @returns T}返回一个新的对象
+ * */
+export declare const mergeDeep: <T>(object: T, source: DeepPartial<T> | T, bool?: boolean) => T;
+/**
+ *判断是否是一个标准的{key:value}对象
+ * @Param {any} obj - 接收的值
+ * @returns {boolean} 如果不是返回false,否则返回true
+ */
+export declare const isObject: (obj: any) => boolean;

package/dist/utils/request.d.ts

@@ -0,0 +1,12 @@
+import { AxiosError, AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+interface Interceptors {
+    requestSuccess: ((config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig)[];
+    requestError: ((error: AxiosError) => AxiosError)[];
+    responseSuccess: ((response: AxiosResponse) => AxiosResponse)[];
+    responseError: ((error: AxiosError) => AxiosError)[];
+}
+type InterceptorType<T extends keyof Interceptors> = Interceptors[T][number];
+export declare const get: <T>(url: string, params?: Record<string, any>, config?: AxiosRequestConfig) => Promise<T>;
+export declare const post: <T>(url: string, params?: Record<string, any>, config?: AxiosRequestConfig) => Promise<T>;
+export declare const addInterceptors: <K extends keyof Interceptors>(type: K, interceptor: InterceptorType<K>) => void;
+export {};