hs-admin-ui 2.1.10 → 2.2.0

package/dist/types/components/business/bcFormTable/utils/useButon.d.ts

@@ -0,0 +1,12 @@
+import { default as BcFormTable } from '../bcFormTable.vue';
+import { VxeTableInstance } from 'vxe-table';
+import { Ref, ComputedRef } from 'vue';
+import { ICustomData, ComponentAttr } from '../../../../types';
+
+export interface BtnEvent {
+    key: string;
+    form?: ICustomData.Data;
+}
+export declare function useButon(formRef: Ref<ICustomData.ANY>, tablesRef: Ref<Record<string, VxeTableInstance>>, activeTabs: Ref<string>, props: ComponentAttr.Props<typeof BcFormTable>): {
+    btns: ComputedRef<ICustomData.Btns[]>;
+};

package/dist/types/components/business/bcFormTable/utils/useTableHeight.d.ts

@@ -0,0 +1,14 @@
+import { Ref, ComputedRef } from 'vue';
+import { VxeTableInstance } from 'vxe-table';
+
+export declare function useTableHeight(): {
+    wrapRef: Ref<HTMLElement | undefined>;
+    btnRef: Ref<HTMLElement | undefined>;
+    formRef: Ref<HTMLElement | undefined>;
+    tableApi: Ref<Record<string, VxeTableInstance>>;
+    style: ComputedRef<{
+        height: string;
+    }>;
+    isOverHide: Ref<boolean>;
+    onReady: (api: VxeTableInstance, id: string) => void;
+};

package/dist/types/components/business/bcGroupComponent/date.vue.d.ts

@@ -0,0 +1,36 @@
+import { DefineComponent, Ref, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+declare const _default: DefineComponent<{
+    value: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    elComponent: {
+        type: StringConstructor;
+        required: true;
+    };
+    fieldComponent: {
+        type: StringConstructor;
+        required: true;
+    };
+}, {
+    elRef: Ref<Record<string, any>>;
+    groupData: Ref<string[]>;
+    focus: () => void;
+    onChange: (val: string[]) => void;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "change"[], "change", PublicProps, Readonly< ExtractPropTypes<{
+    value: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    elComponent: {
+        type: StringConstructor;
+        required: true;
+    };
+    fieldComponent: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/dist/types/components/business/bcIcon/bcIcon.vue.d.ts

@@ -0,0 +1,27 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+declare const _default: DefineComponent<{
+    name: {
+        type: StringConstructor;
+    };
+    size: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    color: {
+        type: StringConstructor;
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+    };
+    size: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    color: {
+        type: StringConstructor;
+    };
+}>>, {
+    size: number;
+}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/bcPageConfig.vue.d.ts

@@ -0,0 +1,11 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+import { IFormTable } from '../../../types';
+
+declare const _default: DefineComponent<{}, {
+    initData: (configList: IFormTable.FormTable[], menu: Record<string, string | import("/@/types").ICustomData.Data>, system: Record<string, string | import("/@/types").ICustomData.Data>) => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    refresh: (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{}>> & {
+    onRefresh?: ((...args: any[]) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsBtn/src/hsAttrBtn.vue.d.ts

@@ -0,0 +1,52 @@
+import { IFormTable } from '../../../../../../types';
+import { PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+
+declare const _default: DefineComponent<{
+    current: {
+        type: PropType<IFormTable.BtnItem>;
+        default(): {};
+    };
+    btnList: {
+        type: {
+            (arrayLength: number): IFormTable.BtnItem[];
+            (...items: IFormTable.BtnItem[]): IFormTable.BtnItem[];
+            new (arrayLength: number): IFormTable.BtnItem[];
+            new (...items: IFormTable.BtnItem[]): IFormTable.BtnItem[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    current: {
+        type: PropType<IFormTable.BtnItem>;
+        default(): {};
+    };
+    btnList: {
+        type: {
+            (arrayLength: number): IFormTable.BtnItem[];
+            (...items: IFormTable.BtnItem[]): IFormTable.BtnItem[];
+            new (arrayLength: number): IFormTable.BtnItem[];
+            new (...items: IFormTable.BtnItem[]): IFormTable.BtnItem[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+}>>, {
+    current: IFormTable.BtnItem;
+    btnList: IFormTable.BtnItem[];
+}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsBtn/src/hsBtnConfigList.vue.d.ts

@@ -0,0 +1,23 @@
+import { IFormTable } from '../../../../../../types';
+import { PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+
+declare const _default: DefineComponent<{
+    modelValue: PropType<IFormTable.BtnItem[]>;
+    current: {
+        type: PropType<Record<"id", string>>;
+        default(): {};
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    chose: (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    modelValue: PropType<IFormTable.BtnItem[]>;
+    current: {
+        type: PropType<Record<"id", string>>;
+        default(): {};
+    };
+}>> & {
+    onChose?: ((...args: any[]) => any) | undefined;
+}, {
+    current: Record<"id", string>;
+}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsBtn/src/hsBtnItemConfig.vue.d.ts

@@ -0,0 +1,21 @@
+import { DefineComponent, PropType, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+import { ICustomData } from '../../../../../../types';
+
+declare const _default: DefineComponent<{
+    modelValue: PropType<ICustomData.BtnData>;
+    config: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+}, {
+    getSubmitData: () => Promise<boolean>;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    modelValue: PropType<ICustomData.BtnData>;
+    config: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+}>>, {
+    config: Record<string, any>;
+}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsBtn/src/hsBtnPanel.vue.d.ts

@@ -0,0 +1,19 @@
+import { DefineComponent, PropType, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+import { IFormTable } from '../../../../../../types';
+
+declare const _default: DefineComponent<{
+    modelValue: PropType<IFormTable.BtnItem[]>;
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    modelValue: PropType<IFormTable.BtnItem[]>;
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    id: string;
+}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsBtn/useAttrBtn.d.ts

@@ -0,0 +1,15 @@
+import { MessageHandler } from 'element-plus';
+import { default as hsAttrBtn } from './src/hsAttrBtn.vue';
+import { ComponentAttr } from '../../../../../types';
+import { Ref } from 'vue';
+
+interface BtnRef {
+    getSubmitData: () => boolean;
+}
+export declare function useHsAttrBtn(props: ComponentAttr.Props<typeof hsAttrBtn>, btnItemRef: Ref<BtnRef>): {
+    visible: Ref<boolean>;
+    btnItemConfig: Ref<any>;
+    btnConfig: Ref<any>;
+    saveData: () => Promise< MessageHandler | undefined>;
+};
+export {};

package/dist/types/components/business/bcPageConfig/components/hsBtn/useBtnConfigList.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+import { IFormTable } from '../../../../../types';
+
+export declare function useHsBtnListConfig(emit: (event: 'chose', ...args: any[]) => void, props: any, // ComponentAttr.Props<typeof hsFormConfigList>,
+btnsModel: Ref<IFormTable.BtnItem[]>): {
+    choseTagItem: (item: IFormTable.BtnItem) => void;
+    appendField: () => void;
+    deleteTagItem: (item: IFormTable.BtnItem) => void;
+};

package/dist/types/components/business/bcPageConfig/components/hsBtn/useBtnItemConfig.d.ts

@@ -0,0 +1,32 @@
+import { ICustomData } from '../../../../../types';
+import { Ref } from 'vue';
+
+interface hsBtnItemConfig {
+    getSubmitData: () => boolean;
+}
+interface RestaurantItem {
+    id: string;
+    field_code: string;
+    field_name: string;
+    json_data: string;
+}
+export declare function useHsBtnItemConfig(data: Ref<ICustomData.BtnData | undefined>, baseConfigRef: Ref<hsBtnItemConfig>): {
+    parentConfig: Ref<{
+        labelWidth: number;
+        span: number;
+        minWidth: number;
+        style: string;
+    }>;
+    requestData: Ref<{
+        url: string;
+        value_key: string;
+        params: {
+            btn_name: string;
+            project_code: string;
+        };
+        qry_key: string;
+    }>;
+    onChangeItem: (item: RestaurantItem) => void;
+    getSubmitData: () => Promise<boolean>;
+};
+export {};

package/dist/types/components/business/bcPageConfig/components/hsExpand/src/hsExpand.vue.d.ts

@@ -0,0 +1,34 @@
+import { DefineComponent, PropType, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<{
+    modelValue: PropType<any>;
+    expandConfig: {
+        type: ObjectConstructor;
+        default: () => {
+            iconSize: number;
+            subTitle: string;
+            class: string;
+            rightSlot: string;
+        };
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    modelValue: PropType<any>;
+    expandConfig: {
+        type: ObjectConstructor;
+        default: () => {
+            iconSize: number;
+            subTitle: string;
+            class: string;
+            rightSlot: string;
+        };
+    };
+}>>, {
+    expandConfig: Record<string, any>;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/business/bcPageConfig/components/hsExpand/useExpand.d.ts

@@ -0,0 +1,3 @@
+export declare function useExpand(visible: any): {
+    toggleExpand: () => void;
+};

package/dist/types/components/business/bcPageConfig/components/hsForm/src/hsAttrForm.vue.d.ts

@@ -0,0 +1,26 @@
+import { IFormTable } from '../../../../../../types';
+import { PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+
+declare const _default: DefineComponent<{
+    current: {
+        type: PropType<IFormTable.ConfigItemType>;
+        default(): {};
+    };
+    data: {
+        type: PropType<Record<string, string | number | boolean>>;
+        default(): {};
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    current: {
+        type: PropType<IFormTable.ConfigItemType>;
+        default(): {};
+    };
+    data: {
+        type: PropType<Record<string, string | number | boolean>>;
+        default(): {};
+    };
+}>>, {
+    data: Record<string, string | number | boolean>;
+    current: IFormTable.ConfigItemType;
+}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsForm/src/hsFormConfigList.vue.d.ts

@@ -0,0 +1,23 @@
+import { IFormTable } from '../../../../../../types';
+import { PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+
+declare const _default: DefineComponent<{
+    modelValue: PropType<IFormTable.FormTable>;
+    current: {
+        type: PropType<Record<"id", string>>;
+        default: () => void;
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    chose: (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    modelValue: PropType<IFormTable.FormTable>;
+    current: {
+        type: PropType<Record<"id", string>>;
+        default: () => void;
+    };
+}>> & {
+    onChose?: ((...args: any[]) => any) | undefined;
+}, {
+    current: Record<"id", string>;
+}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsForm/src/hsFormPanel.vue.d.ts

@@ -0,0 +1,9 @@
+import { DefineComponent, PropType, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+import { IFormTable } from '../../../../../../types';
+
+declare const _default: DefineComponent<{
+    modelValue: PropType<IFormTable.FormTable>;
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    modelValue: PropType<IFormTable.FormTable>;
+}>>, {}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsForm/src/hsFormParse.vue.d.ts

@@ -0,0 +1,9 @@
+import { DefineComponent, PropType, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+import { IFormTable } from '../../../../../../types';
+
+declare const _default: DefineComponent<{
+    modelValue: PropType<IFormTable.FormTable>;
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    modelValue: PropType<IFormTable.FormTable>;
+}>>, {}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsForm/useAttrForm.d.ts

@@ -0,0 +1,39 @@
+import { MessageHandler } from 'element-plus';
+import { default as hsAttrForm } from './src/hsAttrForm.vue';
+import { ComponentAttr } from '../../../../../types';
+import { Ref } from 'vue';
+
+interface BaseConfigRef {
+    getSubmitData: () => boolean;
+}
+interface RestaurantItem {
+    field_code: string;
+    field_name: string;
+    json_data: string;
+    id: string;
+}
+export declare function useHsAttrForm(props: ComponentAttr.Props<typeof hsAttrForm>, baseConfigRef: Ref<BaseConfigRef>): {
+    parentConfig: Ref<{
+        labelWidth: number;
+        span: number;
+        minWidth: number;
+        style: string;
+    }>;
+    visible: Ref<boolean>;
+    formItemConfig: Ref<any>;
+    elComName: Ref<string>;
+    tableConfig: Ref<any>;
+    requestData: Ref<{
+        url: string;
+        params: {
+            field_type: string;
+            field_code: string;
+            project_code: string;
+        };
+        qry_key: string;
+    }>;
+    onChange: (value: string | number, prop: string) => void;
+    saveData: () => Promise< MessageHandler | undefined>;
+    onChangeItem: (item: RestaurantItem) => void;
+};
+export {};

package/dist/types/components/business/bcPageConfig/components/hsForm/useFormListConfig.d.ts

@@ -0,0 +1,9 @@
+import { default as hsFormConfigList } from './src/hsFormConfigList.vue';
+import { Ref } from 'vue';
+import { IFormTable, ComponentAttr } from '../../../../../types';
+
+export declare function useHsFormListConfig(emit: (event: 'chose', ...args: any[]) => void, prop: ComponentAttr.Props<typeof hsFormConfigList>, configModel: Ref<IFormTable.FormTable | undefined>): {
+    choseTagItem: (item: IFormTable.ConfigItemType) => void;
+    appendField: () => void;
+    deleteTagItem: (item: IFormTable.ConfigItemType) => void;
+};

package/dist/types/components/business/bcPageConfig/components/hsForm/useFormParse.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { IFormTable } from '../../../../../types';
+
+export declare function useHsFormParse(parseApi: Ref<string>, configModel: Ref<IFormTable.FormTable | undefined>): {
+    parseForm: () => Promise<void>;
+    parseUrl: Ref<boolean>;
+};

package/dist/types/components/business/bcPageConfig/components/hsSaveForm/saveFormConfig.d.ts

@@ -0,0 +1,70 @@
+declare const newConfig: {
+    formData: {
+        config_name: string;
+        config_unique_id: string;
+        is_auth: string;
+    };
+    formRule: {
+        config_name: {
+            required: boolean;
+            message: string;
+        }[];
+        is_auth: {
+            required: boolean;
+            message: string;
+        }[];
+        config_unique_id: {
+            required: boolean;
+            message: string;
+        }[];
+    };
+    formConfig: ({
+        prop: string;
+        label: string;
+        el: string;
+        required: boolean;
+        attr?: undefined;
+        show?: undefined;
+    } | {
+        prop: string;
+        label: string;
+        el: string;
+        attr: {
+            'active-value': string;
+            'inactive-value': string;
+        };
+        show: boolean;
+        required: boolean;
+    } | {
+        prop: string;
+        label: string;
+        el: string;
+        show: boolean;
+        required: boolean;
+        attr?: undefined;
+    })[];
+};
+declare const selectConfig: {
+    formData: {
+        name: string;
+        config_name: string;
+        is_auth: string;
+        config_unique_id: string;
+    };
+    formRule: {
+        config_name: {
+            required: boolean;
+            message: string;
+        }[];
+        is_auth: {
+            required: boolean;
+            message: string;
+        }[];
+        config_unique_id: {
+            required: boolean;
+            message: string;
+        }[];
+    };
+    formConfig: any;
+};
+export { newConfig, selectConfig };

package/dist/types/components/business/bcPageConfig/components/hsSaveForm/src/saveForm.vue.d.ts

@@ -0,0 +1,53 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+import { IFormTable } from '../../../../../../types';
+
+declare const _default: DefineComponent<{
+    configs: {
+        type: {
+            (arrayLength: number): IFormTable.FormTable[];
+            (...items: IFormTable.FormTable[]): IFormTable.FormTable[];
+            new (arrayLength: number): IFormTable.FormTable[];
+            new (...items: IFormTable.FormTable[]): IFormTable.FormTable[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+}, {
+    initOriginConfig: (configList: IFormTable.FormTable[], index?: number) => Promise<void>;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    delete: (...args: any[]) => void;
+    change: (...args: any[]) => void;
+    save: (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    configs: {
+        type: {
+            (arrayLength: number): IFormTable.FormTable[];
+            (...items: IFormTable.FormTable[]): IFormTable.FormTable[];
+            new (arrayLength: number): IFormTable.FormTable[];
+            new (...items: IFormTable.FormTable[]): IFormTable.FormTable[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: never[];
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+    onDelete?: ((...args: any[]) => any) | undefined;
+    onSave?: ((...args: any[]) => any) | undefined;
+}, {
+    configs: IFormTable.FormTable[];
+}, {}>;
+export default _default;

package/dist/types/components/business/bcPageConfig/components/hsSaveForm/useSaveForm.d.ts

@@ -0,0 +1,27 @@
+import { default as saveForm } from './src/saveForm.vue';
+import { ComponentAttr, IFormTable } from '../../../../../types';
+import { Ref } from 'vue';
+
+interface BcFormRef {
+    getSubmitData: () => boolean;
+}
+export declare function useSaveForm(emits: (event: 'save' | 'change' | 'delete', ...args: any[]) => void, saveFormRef: Ref<BcFormRef>, props: ComponentAttr.Props<typeof saveForm>): {
+    parentConfig: Ref<{
+        showColon: boolean;
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+        xl: number;
+        minWidth: number;
+    }>;
+    formConfig: Ref<any>;
+    isEdit: Ref<boolean>;
+    saveConfig: () => Promise<void>;
+    changeConfig: (value: string, type: string) => void;
+    initOriginConfig: (configList: Array<IFormTable.FormTable>, index?: number) => Promise<void>;
+    addConfig: () => Promise<void>;
+    cancel: () => void;
+    deleteConfig: () => void;
+};
+export {};

package/dist/types/components/business/bcPageConfig/components/hsTables/src/hsAttrTable.vue.d.ts

@@ -0,0 +1,52 @@
+import { IFormTable } from '../../../../../../types';
+import { PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+
+declare const _default: DefineComponent<{
+    current: {
+        type: PropType<IFormTable.TableItem>;
+        default: () => void;
+    };
+    configList: {
+        type: {
+            (arrayLength: number): IFormTable.TableItem[];
+            (...items: IFormTable.TableItem[]): IFormTable.TableItem[];
+            new (arrayLength: number): IFormTable.TableItem[];
+            new (...items: IFormTable.TableItem[]): IFormTable.TableItem[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    current: {
+        type: PropType<IFormTable.TableItem>;
+        default: () => void;
+    };
+    configList: {
+        type: {
+            (arrayLength: number): IFormTable.TableItem[];
+            (...items: IFormTable.TableItem[]): IFormTable.TableItem[];
+            new (arrayLength: number): IFormTable.TableItem[];
+            new (...items: IFormTable.TableItem[]): IFormTable.TableItem[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+}>>, {
+    current: IFormTable.TableItem;
+    configList: IFormTable.TableItem[];
+}, {}>;
+export default _default;