@qqt-product/ui 0.0.12 → 0.0.14

package/dist/lib/components/list-page-layout/src/list-page-layout-types.d.ts

@@ -0,0 +1,358 @@
+import type { PropType, ExtractPropTypes, InjectionKey, Ref, ShallowRef } from 'vue';
+import qqtApi from '@qqt-product/api';
+import type { VxeTableDataRow, VxeGridPropTypes,  VxeTableDefines,  VxeTableInstance } from 'vxe-table';
+export declare const buttonConfigProps: {
+    attrs: {
+        type: PropType<ObjectMap>;
+        default: () => {};
+    };
+    extend: {
+        type: PropType<ObjectMap>;
+        default: () => {};
+    };
+    buttons: {
+        type: PropType<ButtonItem[]>;
+        default: () => never[];
+    };
+};
+export type ButtonConfigProps = ExtractPropTypes<typeof buttonConfigProps>;
+export type ObjectMap = Record<string | number, unknown>;
+export interface OptColumnListItem {
+    type?: string;
+    title: string;
+    authorityCode?: string;
+    attrs?: ObjectMap;
+    args?: {
+        url?: string;
+        [key: string]: unknown;
+    };
+    click?: (args: ListOptionsEventParams) => void;
+    disabled?: (({ currentOpt, row }: {
+        currentOpt: OptColumnListItem;
+        row: ObjectMap;
+    }) => boolean | void) | boolean;
+}
+export interface ButtonItem {
+    label?: string;
+    icon?: string | ObjectMap;
+    type?: string;
+    attrs?: ObjectMap;
+    args?: {
+        url?: string;
+        [key: string]: unknown;
+    };
+    authorityCode?: string;
+    disabled?: (<T>(args: T) => boolean | void) | boolean;
+    click?: (args: ButtonItem) => void;
+    handleBefore?: <T>(args: T) => Promise<T> | void;
+    handleAfter?: <T>(args: T) => Promise<T> | void;
+}
+export interface ToolsButtonItem extends ButtonItem {
+    toggleIcon?: string | ObjectMap;
+}
+export interface QueryFormItem {
+    type: string;
+    label: string;
+    fieldName: string;
+    placeholder?: string;
+    options?: ObjectMap[];
+    dictCode?: string;
+}
+export interface PageData {
+    onlyShowNav?: boolean;
+    optColumn?: {
+        attrs?: ObjectMap;
+        extend?: ObjectMap;
+        optColumnList: OptColumnListItem[];
+    };
+    buttonConfig?: {
+        attrs?: ObjectMap;
+        extend?: ObjectMap;
+        buttons: ButtonItem[];
+    };
+    toolsConfig?: {
+        attrs?: ObjectMap;
+        extend?: ObjectMap;
+        buttons: ToolsButtonItem[];
+    };
+    queryConfig?: {
+        attrs?: ObjectMap;
+        extend?: ObjectMap;
+        form: QueryFormItem[];
+        formState: ObjectMap;
+    };
+    statusConfig?: {
+        show?: (() => boolean | void) | boolean;
+        filter?: ObjectMap;
+        currentValue?: TabListItem;
+    };
+    filterConfig?: {
+        show?: (() => boolean | void) | boolean;
+        filter?: ObjectMap;
+    };
+    navConfig?: {
+        show?: (() => boolean | void) | boolean;
+    };
+    pagerConfig?: VxeGridPropTypes.PagerConfig;
+    [key: string]: unknown;
+}
+export interface TabsData {
+    label?: string;
+    tabList?: TabListItem[];
+}
+export interface TabListItem {
+    proName: string;
+    rejectReason: string;
+    title: string;
+    total: string | number;
+    flag?: string;
+    [key: string]: any;
+}
+export declare const INJECT_KEY_PAGE_DATA: InjectionKey<PageData>;
+export type ListPageLayoutProps = ExtractPropTypes<typeof listPageLayout>;
+export declare const LIST_LAYOUT_PROPS_TOKEN: InjectionKey<ListPageLayoutProps>;
+export declare const LIST_LAYOUT_GRID_DATA_TOKEN: unique symbol;
+export declare const listPageLayout: {
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    extraListConfig: {
+        type: PropType<ObjectMap>;
+        default: () => {};
+    };
+    pageData: {
+        type: PropType<PageData>;
+        default: () => {};
+    };
+    apiUrls: {
+        type: PropType<ApiUrls>;
+        default: () => {};
+    };
+};
+export type ListContent = ExtractPropTypes<typeof listContent>;
+export declare const LIST_CONTENT_TOKEN: InjectionKey<ListContent>;
+export declare const listContent: {
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    extraListConfig: {
+        type: PropType<ObjectMap>;
+        default: () => {};
+    };
+    tableColumns: {
+        type: PropType<VxeGridPropTypes.Columns<VxeTableDataRow>>;
+        default: () => never[];
+    };
+    pageData: {
+        type: PropType<PageData>;
+        default: () => {};
+    };
+    tabsData: {
+        type: PropType<TabsData>;
+        default: () => {};
+    };
+    apiUrls: {
+        type: PropType<ApiUrls>;
+        default: () => {};
+    };
+    filterList: never[];
+};
+export interface ButtonConfig {
+    attrs?: ObjectMap;
+    extend?: ObjectMap;
+    buttons: ButtonItem[];
+}
+export interface ToolsConfig {
+    attrs?: ObjectMap;
+    extend?: ObjectMap;
+    buttons: ToolsButtonItem[];
+}
+export type EventHandler = <T>(args: T) => void;
+export interface ApiUrls {
+    columnsCode: string;
+    list: string;
+    countTabsUrl: string;
+    quickNav?: string;
+    [key: string]: unknown;
+}
+export type PagerAlign = 'right' | 'center' | 'left';
+export type PageLayouts = 'PrevJump' | 'PrevPage' | 'JumpNumber' | 'NextPage' | 'NextJump' | 'Sizes' | 'FullJump' | 'PageCount' | 'Total';
+export declare const pagerConfigProps: {
+    total: NumberConstructor;
+    pages: NumberConstructor;
+    currentPage: NumberConstructor;
+    pageSize: NumberConstructor;
+    pageSizes: {
+        (arrayLength: number): number[];
+        (...items: number[]): number[];
+        new (arrayLength: number): number[];
+        new (...items: number[]): number[];
+        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;
+    };
+    align: PropType<PagerAlign>;
+    layouts: PropType<PageLayouts[]>;
+    perfect: BooleanConstructor;
+};
+export type PagerConfigProps = ExtractPropTypes<typeof pagerConfigProps>;
+export interface IsOrder {
+    column: string;
+    order: string;
+}
+export interface QueryCustomData {
+    isOrder?: IsOrder;
+    filter?: ObjectMap;
+    queryForm?: ObjectMap;
+}
+export declare const otherDataProps: {
+    isOrder: {
+        type: PropType<IsOrder>;
+        default: () => {
+            column: string;
+            order: string;
+        };
+    };
+    filter: {
+        type: PropType<ObjectMap>;
+        default: () => {};
+    };
+};
+export interface FetchDataReturn {
+    tableData: Ref<ObjectMap[]>;
+    otherDatas?: QueryCustomData;
+    pagerConfig: Ref<VxeGridPropTypes.PagerConfig>;
+    loading: ShallowRef<boolean>;
+}
+export interface GridDataTypes extends FetchDataReturn {
+    updateListData: (params?: FetchDataOptions, customRequest?: qqtApi.Request) => void;
+    tableColumns: Ref<VxeGridPropTypes.Columns>;
+}
+export interface FetchDataOptions {
+    propsData?: ListContent | {
+        [key: string]: any;
+    };
+    extraParams?: {
+        [key: string]: unknown;
+    };
+    pagerConfig?: VxeGridPropTypes.PagerConfig;
+    formState?: ObjectMap;
+    statusFilter?: ObjectMap;
+    getParams?: () => {
+        [key: string]: unknown;
+    };
+}
+export interface CurrentRow {
+    templateNumber: string;
+    templateVersion: number;
+    templateAccount: string;
+    busAccount: string;
+    elsAccount: string;
+    [key: string]: unknown;
+}
+export interface ListOptionsEventParams {
+    row: CurrentRow;
+    optionItem?: OptColumnListItem;
+    column: VxeGridPropTypes.Columns | VxeTableDefines.ColumnInfo;
+    $rowIndex: number;
+    $columnIndex: number;
+}
+export interface OptionsButtonsCallBack extends ListOptionsEventParams {
+    click?: (params: ListOptionsEventParams) => void;
+}
+export type RemoveRowFunction = (options: {
+    loading: Ref<boolean>;
+    Request: qqtApi.Request;
+    action?: string;
+    params: {
+        id: string | number | unknown;
+    };
+}, cb?: (res: any) => void) => Promise<void>;
+export interface QueryParamsItem {
+    logicSymbol?: string;
+    fieldCode?: string;
+    dictCode?: string;
+    fieldType?: string;
+    fieldValue?: string | number;
+    showValue?: string | number;
+    joiner?: string | number;
+    dictTable?: string | number;
+    customReturnField?: string | number;
+    queryItemId?: string | number;
+    extendLink?: string;
+    extend?: {
+        bindFunction?: (args: object) => void;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface UserInfo {
+    elsAccount: string;
+    subAccount: string;
+    serivceUrl: string;
+    [key: string]: unknown;
+}
+export interface SearchPrompt {
+    visible: boolean;
+    form: {
+        value: string | number;
+    };
+    formRules: any;
+}
+export interface SearchTreeDataItem {
+    title: string | number;
+    icon: string;
+    records: QueryParamsItem[];
+    id?: string;
+}
+export interface DictCodeItem {
+    title: string;
+    value: string;
+    [key: string]: unknown;
+}
+export interface ExportXlsOptions {
+    fileName?: string;
+    loading: ShallowRef<boolean>;
+    pageData: PageData;
+    pagerConfig: VxeGridPropTypes.PagerConfig;
+    gridInstance: VxeTableInstance;
+    apiUrls: ApiUrls;
+    exportType?: string;
+    templateId?: string;
+    templateNumberVersion?: string;
+    otherDatas?: QueryCustomData;
+    itemGroupCode?: string;
+    jsonParam?: ObjectMap;
+    defineColumnCode?: string;
+    exportXlsUrl?: string;
+    [key: string]: unknown;
+}
+export interface GridColumn {
+    field?: string;
+    property?: string;
+    columnId?: string;
+    sorter?: string;
+    fixType?: string;
+    hidden?: string;
+    link?: string;
+    fieldColors?: GridColors[] | string;
+    [key: string]: any;
+}
+export interface GridColors {
+    fieldName?: string;
+    filterColor?: string;
+    [key: string]: unknown;
+}
+export interface ExposeByListButtons {
+    updateListData: (params?: FetchDataOptions, customRequest?: qqtApi.Request) => void;
+    loading: Ref<boolean>;
+    listGridRef: Ref<VxeTableInstance>;
+    Request: qqtApi.Request;
+}

package/dist/lib/components/list-page-layout/src/symbol.d.ts

@@ -0,0 +1,11 @@
+export declare const SYMBOL_GRID_INSTANCE: unique symbol;
+export declare const SYMBOL_HANDLE_SETTING: unique symbol;
+export declare const SYMBOL_HANDLE_ADD: unique symbol;
+export declare const SYMBOL_HANDLE_EXPORT: unique symbol;
+export declare const SYMBOL_HANDLE_IMPORT: unique symbol;
+export declare const SYMBOL_HANDLE_RECORD: unique symbol;
+export declare const SYMBOL_HANDLE_QUICK_NAV: unique symbol;
+export declare const SYMBOL_HANDLE_HELP_TEXT: unique symbol;
+export declare const SYMBOL_HANDLE_ATTACHMENT_TEXT: unique symbol;
+export declare const SYMBOL_HANDLE_VIDEO_TEXT: unique symbol;
+export declare const SYMBOL_FETCH_NAV_DATA: unique symbol;

package/dist/lib/components/list-page-layout/src/tokens.d.ts

@@ -0,0 +1,12 @@
+import { ComponentInternalInstance, InjectionKey } from 'vue';
+import { GridDataTypes, ListPageLayoutProps, QueryCustomData, PagerConfigProps } from './list-page-layout-types';
+interface ListPage extends ComponentInternalInstance {
+    $ready?: boolean;
+}
+export declare const TABLE_INJECTION_KEY: InjectionKey<ListPage | null>;
+export declare const PAGER_CONFIGDE_FALUTVALUE: PagerConfigProps;
+export declare const LIST_LAYOUT_PROPS_DEFAULT_VALUE: ListPageLayoutProps;
+export declare const LOCAL_DATAS_DEFAULT_VALUE: QueryCustomData;
+export declare const LIST_LAYOUT_STATUS_NAV_TOKEN: unique symbol;
+export declare const LIST_LAYOUT_DATA_TOKEN: InjectionKey<GridDataTypes>;
+export {};

package/dist/lib/components/list-page-layout/src/types.d.ts

@@ -0,0 +1 @@
+export type { GridColumn, ExportXlsOptions, ButtonItem, DictCodeItem, SearchTreeDataItem, UserInfo, QueryParamsItem, ListOptionsEventParams, FetchDataOptions, ApiUrls, ObjectMap, IsOrder, TabListItem, PageData, QueryFormItem, OptColumnListItem, CurrentRow, } from './list-page-layout-types';

package/dist/lib/components/list-page-layout/src/utils/gridConfig.d.ts

@@ -0,0 +1,174 @@
+export declare const ListConfig: {
+    border: string;
+    stripe: boolean;
+    resizable: boolean;
+    autoResize: boolean;
+    showOverflow: boolean;
+    keepSource: boolean;
+    showHeaderOverflow: boolean;
+    size: string;
+    height: string;
+    headerAlign: string;
+    columnKey: boolean;
+    checkboxConfig: {
+        highlight: boolean;
+        reserve: boolean;
+        trigger: string;
+    };
+    toolbarConfig: {
+        enabled: boolean;
+        slots: {
+            buttons: string;
+        };
+        print: boolean;
+        zoom: boolean;
+        perfect: boolean;
+    };
+    sortConfig: {
+        remote: boolean;
+    };
+    clipConfig: {
+        isCut: boolean;
+        isPaste: boolean;
+    };
+    fnrConfig: {
+        isFind: boolean;
+        isReplace: boolean;
+    };
+    mouseConfig: {
+        area: boolean;
+        extension: boolean;
+    };
+    keyboardConfig: {
+        isClip: boolean;
+        isTab: boolean;
+        isArrow: boolean;
+        isFNR: boolean;
+        enterToTab: boolean;
+    };
+    menuConfig: {
+        body: {
+            options: ({
+                code: string;
+                name: string;
+                prefixIcon: string;
+            }[] | {
+                name: string;
+                prefixIcon: string;
+                children: ({
+                    code: string;
+                    name: string;
+                    prefixIcon: string;
+                    params?: undefined;
+                } | {
+                    code: string;
+                    name: string;
+                    prefixIcon: string;
+                    params: {
+                        category: string;
+                    };
+                })[];
+            }[])[];
+        };
+    };
+};
+export declare const EditConfig: {
+    border: boolean;
+    stripe: boolean;
+    resizable: boolean;
+    autoResize: boolean;
+    keepSource: boolean;
+    height: string;
+    showOverflow: boolean;
+    showHeaderOverflow: boolean;
+    columnKey: boolean;
+    highlightHoverRow: boolean;
+    size: string;
+    align: string;
+    headerAlign: string;
+    data: never[];
+    mouseConfig: {
+        area: boolean;
+        extension: boolean;
+    };
+    clipConfig: {
+        isCut: boolean;
+        isPaste: boolean;
+    };
+    keyboardConfig: {
+        isClip: boolean;
+        isEdit: boolean;
+        isTab: boolean;
+        isArrow: boolean;
+        isEnter: boolean;
+        isDel: boolean;
+        isMerge: boolean;
+        isFNR: boolean;
+        isChecked: boolean;
+        enterToTab: boolean;
+    };
+    checkboxConfig: {
+        highlight: boolean;
+        trigger: string;
+    };
+    editConfig: {
+        trigger: string;
+        mode: string;
+        showStatus: boolean;
+    };
+    toolbarConfig: {
+        slots: {
+            buttons: string;
+        };
+        perfect: boolean;
+    };
+    menuConfig: {
+        body: {
+            options: (({
+                code: string;
+                name: string;
+                visible: boolean;
+                prefixIcon?: undefined;
+            } | {
+                code: string;
+                name: string;
+                prefixIcon: string;
+                visible?: undefined;
+            })[] | {
+                name: string;
+                prefixIcon: string;
+                children: ({
+                    code: string;
+                    name: string;
+                    prefixIcon: string;
+                    params?: undefined;
+                } | {
+                    code: string;
+                    name: string;
+                    prefixIcon: string;
+                    params: {
+                        category: string;
+                    };
+                })[];
+            }[] | ({
+                code: string;
+                name: string;
+                prefixIcon: string;
+                params: {
+                    columns: string[];
+                    filename?: undefined;
+                    type?: undefined;
+                };
+            } | {
+                code: string;
+                name: string;
+                prefixIcon: string;
+                params: {
+                    filename: string;
+                    type: string;
+                    columns?: undefined;
+                };
+            })[])[];
+        };
+    };
+};

package/dist/lib/components/page-layout/index.d.ts

@@ -1,9 +1,14 @@
-import type { LayoutConfig } from '../edit-page-layout';
+import type { RecordStringNumber, LayoutConfig } from '../edit-page-layout';
 import type { DefineComponent, ComponentPropsOptions, ComputedRef, Ref, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps, ExtractPropTypes, ComponentObjectPropsOptions } from 'vue';
 import type { SFCWithInstall } from '@qqt-product/utils/dist/modules/withInstall';
 import QPageLayout from './src/page-layout.vue';
 export * from './src/page-layout-types';
 export * from './src/token';
+export * from './src/constant';
+export * from './src/util';
+import usePromiseStepHook from './src/hook/use-promise-step';
+import useRefInstanceHook from './src/hook/use-ref-instance-hook';
+export { usePromiseStepHook, useRefInstanceHook };
 export { QPageLayout };
 declare const _default: SFCWithInstall<DefineComponent<Readonly<ComponentPropsOptions<{
     [x: string]: unknown;
@@ -11,10 +16,15 @@ declare const _default: SFCWithInstall<DefineComponent<Readonly<ComponentPropsOp
     classes: ComputedRef<{
         [key: string]: string | boolean;
     }>;
+    defaultValues: Ref<RecordStringNumber>;
     layoutConfig: Ref<LayoutConfig>;
+    pageData: Ref<RecordStringNumber>;
+    loading: Ref<boolean>;
+    layoutLoading: Ref<boolean>;
+    customLoading: Ref<boolean>;
 }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, readonly string[] | Readonly<ExtractPropTypes<Readonly<ComponentObjectPropsOptions<{
     [x: string]: unknown;
 }>>>>, {
     [x: number]: string;
-} | {}>>;
+} | {}, {}>>;
 export default _default;

package/dist/lib/components/page-layout/src/constant/buttons.d.ts

@@ -0,0 +1,10 @@
+import type { PageButton, PageUploadButton } from '../../../edit-page-layout';
+export declare const BUTTON_DELETE_ROW: PageButton;
+export declare const BUTTON_ADD_ONE_ROW: PageButton;
+export declare const BUTTON_SAVE: PageButton;
+export declare const BUTTON_PUBLISH: PageButton;
+export declare const BUTTON_SUBMIT: PageButton;
+export declare const BUTTON_CUSTOM: PageButton;
+export declare const BUTTON_CUSTOM_PRIMARY: PageButton;
+export declare const BUTTON_CUSTOM_DANGER: PageButton;
+export declare const BUTTON_UPLOAD: PageUploadButton;

package/dist/lib/components/page-layout/src/constant/index.d.ts

@@ -0,0 +1,3 @@
+export * from './symbol';
+export * from './buttons';
+export * from './items';

package/dist/lib/components/page-layout/src/constant/items.d.ts

@@ -0,0 +1,3 @@
+import type { FormFieldsItem, ColumnItem } from '../../../edit-page-layout';
+export declare const FORMITEM: FormFieldsItem;
+export declare const COLUMNITEM: ColumnItem;

package/dist/lib/components/page-layout/src/constant/symbol.d.ts

@@ -0,0 +1,15 @@
+export declare const SYMBOL_ADD_ONE_ROW: unique symbol;
+export declare const SYMBOL_DELETE_ROWS: unique symbol;
+export declare const SYMBOL_SAVE: unique symbol;
+export declare const SYMBOL_PUBLISH: unique symbol;
+export declare const SYMBOL_SUBMIT: unique symbol;
+export declare const SYMBOL_VALIDATE: unique symbol;
+export declare const SYMBOL_VALIDATE_RESULT: unique symbol;
+export declare const SYMBOL_VALIDATE_SUCCESS: unique symbol;
+export declare const SYMBOL_REFRESH: unique symbol;
+export declare const SYMBOL_BACK: unique symbol;
+export declare const SYMBOL_BINDFUNCTION: unique symbol;
+export declare const SYMBOL_VXE_BINDFUNCTION: unique symbol;
+export declare const SYMBOL_CUSTOM_CLICK: unique symbol;
+export declare const SYMBOL_UPLOAD: unique symbol;
+export declare const SYMBOL_UPLOAD_GRID: unique symbol;

package/dist/lib/components/page-layout/src/hook/use-merge-defaultValues-hook.d.ts

@@ -0,0 +1,6 @@
+import type { Ref } from 'vue';
+import type { RecordStringNumber, LayoutConfig } from '../../../edit-page-layout';
+export default function usePageData(rawPageData: Ref<RecordStringNumber>, defaultValues: Ref<RecordStringNumber>, layoutConfig: Ref<LayoutConfig>): {
+    pageData: Ref<RecordStringNumber>;
+    isFinishData: Ref<boolean>;
+};

package/dist/lib/components/page-layout/src/hook/use-page-data-hook.d.ts

@@ -0,0 +1,6 @@
+import type { Ref } from 'vue';
+import type { RecordStringNumber } from '../../../edit-page-layout';
+export default function usePageData(): {
+    rawPageData: Ref<RecordStringNumber>;
+    loading: Ref<boolean>;
+};

package/dist/lib/components/page-layout/src/hook/use-promise-step.d.ts

@@ -0,0 +1,26 @@
+import type { Ref } from 'vue';
+import type { ExposeWithPageButtons, PageButton, ValidateResult } from '../../../edit-page-layout';
+export default function usePromiseStep<T extends ExposeWithPageButtons>(payload: T): {
+    customLoading: Ref<boolean>;
+    normalizeStepPromiseMethod: <T_1 extends ExposeWithPageButtons>(key: string | symbol) => ((args: T_1) => Promise<ExposeWithPageButtons>)[];
+    handleResetValidateStatus: (btn: PageButton) => void;
+    handleValidateResult: ({ result, button }: ValidateResult) => void;
+    stepSave: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepAdd: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepTriggerValidate: (symbolKey?: symbol | string) => void;
+    stepHideMessage: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepShowMessage: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepCheckBeforePublish: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepCheckBeforeSubmit: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepIsExistFrozenSource: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepConfirmPublish: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepConfirmSubmit: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepPublish: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    stepSubmit: (args: ExposeWithPageButtons) => Promise<ExposeWithPageButtons>;
+    promiseSaveSteps: (showMessage?: boolean) => Promise<ExposeWithPageButtons>;
+    composeSave: (symbolKey?: symbol | string) => void;
+    composePublish: (symbolKey?: symbol | string) => void;
+    restOfPublish: (button: PageButton) => void;
+    composeSubmit: (symbolKey?: symbol | string) => void;
+    restOfSubmit: (button: PageButton) => void;
+};

package/dist/lib/components/page-layout/src/hook/use-ref-instance-hook.d.ts

@@ -0,0 +1,7 @@
+import type { Ref, ComponentPublicInstance } from 'vue';
+import type { LayoutConfig, RecordStringNumber } from '../../../edit-page-layout';
+export default function useRefInstance(layoutRef: Ref<ComponentPublicInstance | null>): {
+    pageData: Ref<RecordStringNumber>;
+    layoutConfig: Ref<LayoutConfig>;
+    defaultValues: Ref<RecordStringNumber>;
+};

package/dist/lib/components/page-layout/src/hook/use-remote-config-hook.d.ts

@@ -1,5 +1,8 @@
 import type { Ref } from 'vue';
-import type { EditPageLayoutProps, LayoutConfig } from '../../../edit-page-layout';
-export default function useRemoteConfig(props: EditPageLayoutProps): {
+import type { LayoutConfig, RecordStringNumber } from '../../../edit-page-layout';
+export default function useRemoteConfig(): {
     layoutConfig: Ref<LayoutConfig>;
+    defaultValues: Ref<RecordStringNumber>;
+    layoutLoading: Ref<boolean>;
+    isFinishConfig: Ref<boolean>;
 };