@byteluck-fe/runtime-engine 1.5.0 → 2.0.0

package/dist/src/hooks/controls/ElectronicSignature/useElectronicSignature.d.ts

@@ -1,16 +1,19 @@
-import { ComputedRef, Ref } from 'vue';
-import { PAGE_STATUS, ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
-export declare const useElectronicSignature: (props: {
-    instance: ControlRuntimeInstance<'electronic-signature'>;
-    rowIndex?: number;
-    value?: string;
-}, errorToast: (message: string) => void) => {
+import { Ref, ComputedRef } from 'vue';
+import { CONTROL_TYPE, PAGE_STATUS } from '@byteluck-fe/model-driven-core-all';
+import { PropsInstanceType } from '../../../constant';
+
+export declare const useElectronicSignature: (props: PropsInstanceType<CONTROL_TYPE.ELECTRONIC_SIGNATURE>, errorToast: (message: string) => void) => {
     queryStatus: () => void;
-    signStatus: any;
+    signStatus: Ref<{
+        name: string;
+        tips: string;
+        type: string;
+        status: string;
+    }>;
     startSign: () => Promise<void>;
     buttonClick: () => void;
     staHover: () => Promise<void>;
-    signMemberLists: any;
+    signMemberLists: Ref<any>;
     memberSignSta: {
         Pending: string;
         Completed: string;
@@ -20,5 +23,5 @@ export declare const useElectronicSignature: (props: {
     mobileShowPopup: Ref<boolean>;
     mobilPopopActiveTab: Ref<string>;
     signResult: any;
-    pageStatus: ComputedRef<PAGE_STATUS | undefined>;
+    pageStatus: ComputedRef<PAGE_STATUS>;
 };

package/dist/src/hooks/controls/actionBar/index.d.ts

@@ -0,0 +1 @@
+export * from './useActionBar';

package/dist/src/hooks/controls/cardGroup/useCardGroup.d.ts

@@ -1,4 +1,5 @@
 import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
+
 export declare function useCardGroup(props: {
     instance: ControlRuntimeInstance<'card-group'>;
 }): void;

package/dist/src/hooks/controls/dataView/const.d.ts

@@ -0,0 +1,13 @@
+export declare const messageMap: {
+    form: {
+        saveAs: string;
+        save: string;
+    };
+    process: {
+        saveAs: string;
+        save: string;
+    };
+    opertaion: {
+        button: string;
+    };
+};

package/dist/src/hooks/controls/dataView/index.d.ts

@@ -1 +1,2 @@
 export * from './useDataView';
+export * from './const';

package/dist/src/hooks/controls/decimalColumn/useDecimalColumn.d.ts

@@ -1,11 +1,7 @@
+import { PropsInstanceType } from '../../../constant';
+import { CONTROL_TYPE } from '@byteluck-fe/model-driven-core-all';
 import { ComputedRef } from 'vue';
-import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
-interface UseDecimalColumnProps {
-    instance: ControlRuntimeInstance<'decimal-column'>;
-    value: number | '';
-    rowRecord?: object;
-}
-export declare function useDecimalColumn(props: UseDecimalColumnProps): {
-    showValue: ComputedRef<string | number>;
+
+export declare function useDecimalColumn(props: PropsInstanceType<CONTROL_TYPE.DECIMAL_COLUMN>): {
+    showValue: ComputedRef<string | number | undefined>;
 };
-export {};

package/dist/src/hooks/controls/file/index.d.ts

@@ -0,0 +1 @@
+export * from './useUploading';

package/dist/src/hooks/controls/file/useUploading.d.ts

@@ -0,0 +1,3 @@
+export declare const useUploading: () => {
+    uploading: (params: CustomEvent) => void;
+};

package/dist/src/hooks/controls/form/interface.d.ts

@@ -0,0 +1,21 @@
+import { ComponentInternalInstance, ComputedRef } from 'vue';
+import { RuleItem, Rules } from 'async-validator';
+
+export interface SuperFormExpose {
+    addField(eventKey: string, context: any): void;
+    removeField(eventKey: string): void;
+    rules: ComputedRef<Rules | undefined>;
+    model: ComputedRef<Record<string, unknown>>;
+}
+export type InternalNamePath = (string | number)[];
+export type NamePath = string | number | InternalNamePath;
+export interface FieldExpose {
+    fieldValue: ComputedRef<any>;
+    fieldName: ComputedRef<any>;
+    resetField: () => void;
+    clearValidate: () => void;
+    namePath: ComputedRef<InternalNamePath>;
+    rules?: ComputedRef<RuleItem[]>;
+    validateField: () => Promise<void>;
+    instance: ComponentInternalInstance;
+}

package/dist/src/hooks/controls/form/useFormContext.d.ts

@@ -0,0 +1,4 @@
+import { SuperFormExpose } from './interface';
+
+export declare function useFormContextProvider(state: SuperFormExpose): void;
+export declare function useFormContextInjector(): SuperFormExpose | null;

package/dist/src/hooks/controls/form/utils.d.ts

@@ -0,0 +1,22 @@
+import { VNode, RendererNode, RendererElement } from 'vue';
+import { NamePath, InternalNamePath } from './interface';
+
+export declare function isValid(value: any): boolean;
+export declare function isEmptyElement(c: any): boolean;
+export declare function isValidElement(element: any): any;
+export declare const flattenChildren: (children?: any[], filterEmpty?: boolean) => any[];
+export declare function filterEmpty(children?: any[]): any[];
+export declare function cloneElement(vnode: VNode, nodeProps?: {}, override?: boolean, mergeRef?: boolean): VNode< RendererNode, RendererElement, {
+    [key: string]: any;
+}> | null;
+export declare function cloneVNodes(vnodes: VNode[], nodeProps?: {}, override?: boolean): (VNode< RendererNode, RendererElement, {
+    [key: string]: any;
+}> | null)[];
+export declare function isString(arg: unknown): arg is string;
+export declare function getNamePath(name?: NamePath): InternalNamePath;
+export declare function getPropByPath(obj: any, namePathList: any, strict?: boolean): {
+    o: any;
+    k: any;
+    v: any;
+};
+export declare function toArray<T>(value?: T | T[] | null): T[];

package/dist/src/hooks/controls/form/validateUtils.d.ts

@@ -0,0 +1,19 @@
+import { RuleItem } from 'async-validator';
+import { InternalNamePath } from './interface';
+
+/**
+ * Replace with template.
+ *   `I'm ${name}` + { name: 'bamboo' } = I'm bamboo
+ */
+export declare function replaceMessage(template: string, kv: Record<string, string>): string;
+export declare function validateRule(name: string, value: any, rule: RuleItem): Promise<string[]>;
+/**
+ * We use `async-validator` to validate the value.
+ * But only check one value in a time to avoid namePath validate issue.
+ */
+export declare function validateRules(namePath: (string | number)[], value: any, rules: RuleItem[]): Promise<any[]>;
+export declare function finishOnAllFailed(rulePromises: Promise<any>[]): Promise<any[]>;
+export declare function finishOnFirstFailed(rulePromises: Promise<any>[]): Promise<any[]>;
+export declare function allPromiseFinish(promiseList: Promise<any>[]): Promise<any[]>;
+export declare function containsNamePath(namePathList: InternalNamePath[], namePath: InternalNamePath): boolean;
+export declare function matchNamePath(namePath: InternalNamePath, changedNamePath: InternalNamePath | null): boolean;

package/dist/src/hooks/controls/index.d.ts

@@ -23,3 +23,4 @@ export * from './useInstanceId';
 export * from './useAttachmentPreview';
 export * from './useForceUpdate';
 export * from './useAttachmentPreview';
+export * from './actionBar';

package/dist/src/hooks/controls/listMaster/useListMaster.d.ts

@@ -1,7 +1,8 @@
-import { Ref } from 'vue';
 import { Engine } from '@byteluck-fe/model-driven-engine';
+import { Ref } from 'vue';
+
 export declare function useListMaster(): {
     state: any;
     hasPermission: Ref<boolean>;
-    onEngineInit: (engine: Engine) => void;
+    onEngineInit: (engine: Engine) => Promise<void>;
 };

package/dist/src/hooks/controls/listMaster/useModel.d.ts

@@ -1,4 +1,5 @@
 import { Ref } from 'vue';
+
 export declare function useInitListMaster(masterDataCode: Ref<string>): {
     state: {
         data: any;

package/dist/src/hooks/controls/listSelectButton/useEngineFillState.d.ts

@@ -1,10 +1,14 @@
 import { Ref } from 'vue';
 import { ControlRuntimeInstance, MultistageFillingItem } from '@byteluck-fe/model-driven-core-all';
+import { Engine } from '@byteluck-fe/model-driven-engine';
+
 /**
  * 处理engine填充数据的方法
  * */
-export declare function useEngineFillState(instance: ControlRuntimeInstance<'list-select-button'>, fillList: Ref<MultistageFillingItem[]>, primaryKeyFilledControlId?: Ref<string | undefined>): {
-    handlerFillState: (state: Record<string, unknown> | undefined, rowIndex?: number | undefined, concat?: Ref<boolean> | boolean) => void;
+export declare function useEngineFillState(instance: ControlRuntimeInstance<'list-select-button'>, fillList: Ref<MultistageFillingItem[]>, primaryKeyFilledControlId?: Ref<string | undefined>, options?: {
+    engine?: Engine | Ref<Engine>;
+}): {
+    handlerFillState: (state: Record<string, unknown> | undefined, rowIndex?: number, concat?: Ref<boolean> | boolean) => void;
     handlerFillSubtableState: (state: Array<Record<string, unknown>> | undefined, dataCode: string) => void;
     handlerComputedState: () => Record<string, unknown>;
     mergedStatesToObject: (rows: Array<Record<string, unknown>>) => Record<string, string[]>;

package/dist/src/hooks/controls/listSelectButton/useListSelectButton.d.ts

@@ -1,18 +1,20 @@
-import { ComputedRef, Ref } from 'vue';
-import { SelectStateType } from '../../components';
-import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
+import { Ref, ShallowRef, ComputedRef } from 'vue';
+import { SelectStateType } from '../listView/useListSelection';
+import { CONTROL_TYPE, ControlPropertyInstance } from '@byteluck-fe/model-driven-core-all';
 import { Engine } from '@byteluck-fe/model-driven-engine';
+import { PropsInstanceType } from '../../../constant';
+
 /**
  * 处理列表选择按钮逻辑
  * */
-export declare function useListSelectButton(props: {
-    instance: ControlRuntimeInstance<'list-select-button'>;
-    rowIndex?: number;
+export declare function useListSelectButton(props: PropsInstanceType<CONTROL_TYPE.LIST_SELECT_BUTTON>, instanceProps: ShallowRef<ControlPropertyInstance<CONTROL_TYPE.LIST_SELECT_BUTTON>>, options?: {
+    engine?: Engine;
+    visible?: Ref<boolean>;
 }): {
     visible: Ref<boolean>;
     disabled: ComputedRef<boolean>;
     value: Ref<string | string[] | undefined>;
     handlerClick: () => void;
     handlerClickOk: (selectState: SelectStateType) => Promise<void>;
-    onEngineInit: (engine: Engine) => void;
+    onEngineInit: (engine: Engine, rowIndex?: number) => Promise<void>;
 };

package/dist/src/hooks/controls/listView/index.d.ts

@@ -1 +1,2 @@
 export * from './useModel';
+export * from './useGetListInstance';

package/dist/src/{entry_desktop/controls/rok-grid-table/hooks → hooks/controls/listView}/useIframe.d.ts

@@ -1,4 +1,5 @@
 import { Ref } from 'vue';
+
 export default function useIframe(url: string, formVisible: Ref<boolean>, callback?: Fn): {
-    handlePostMate: () => Promise<void>;
+    handlePostMate: () => Promise<any>;
 };

package/dist/src/hooks/controls/listView/useListActionsEvent.d.ts

@@ -1,5 +1,6 @@
 import { BTN_TYPE } from '../../../utils';
 import { ControlRuntimeInstance, ControlsKeys } from '@byteluck-fe/model-driven-core-all';
+
 export declare function useListActionsEvent(instance: MayBeRef<ControlRuntimeInstance<ControlsKeys>>): {
     getActionsPayload: (type: BTN_TYPE, payload: Record<string, unknown> & {
         record?: Record<string, unknown>;

package/dist/src/hooks/controls/listView/useModel.d.ts

@@ -4,7 +4,8 @@ import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
 import { PaginationProps } from '../../../types/PaginationProps';
 import { ISearchType } from '../../../types/controls/simple-search';
 import { IOrderType } from '../../../types/controls/list-view';
-export declare type listViewModelParams = {
+
+export type listViewModelParams = {
     instance: ControlRuntimeInstance<'list-view'>;
     refs: Ref<any[]>;
     hasTree: ComputedRef<boolean>;
@@ -20,20 +21,33 @@ export declare type listViewModelParams = {
     shrinkPopoverVisible?: Ref<boolean>;
     filterTreeKeys?: Ref<string[]>;
     refreshTree?: Fn;
-    organizationProps?: any;
+    gridTableControl?: any;
+    fillFields: string[];
 };
-export declare type fetchTableListParams = {
+export type fetchTableListParams = {
     paginationInfo?: PaginationProps;
     ordersInfo?: IOrderType[];
     queryInfo?: ISearchType[];
     filtersInfo?: Recordable<any>[];
     isFilter?: boolean;
+    isSerach?: boolean;
+    isPageChange?: boolean;
     clear?: boolean;
+    isPost?: string;
+    isViewSearch?: boolean;
 };
 export declare function useListViewModel(params: listViewModelParams): {
-    queryData: any;
-    listData: Ref<any[]>;
-    listPagination: any;
-    fetchTableList: ({ paginationInfo, ordersInfo, queryInfo, filtersInfo, isFilter, clear, }: fetchTableListParams) => Promise<void>;
+    isPageInit: Ref<boolean>;
+    queryData: Ref<any>;
+    listData: Ref<any>;
+    statisticsData: any;
+    pageConfig: Ref<{}>;
+    symbolIndexList: any;
+    listPagination: Ref<any>;
+    fetchTableList: ({ paginationInfo, ordersInfo, queryInfo, filtersInfo, isFilter, clear, isPost, isPageChange, isSerach, isViewSearch, }: fetchTableListParams, options?: {
+        token: Number;
+    }) => Promise<void>;
+    isShowAgGridFooterStatistics: Ref<boolean>;
     deleteTableRow: (record: Recordable<unknown>, condition?: any) => Promise<void>;
+    getNoCountListMaxSize: ({ paginationInfo, ordersInfo, queryInfo, filtersInfo, isFilter, clear, }: fetchTableListParams) => Promise<{} | undefined>;
 };

package/dist/src/hooks/controls/listView/useOperate.d.ts

@@ -0,0 +1,17 @@
+import { Ref, ComputedRef } from 'vue';
+import { RouteLocationNormalizedLoaded, Router } from 'vue-router';
+import { Engine } from '@byteluck-fe/model-driven-engine';
+import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
+import { BTN_TYPE } from '../../../utils';
+
+export default function useOperate(instance: ControlRuntimeInstance<'operation-column'> | ControlRuntimeInstance<'varchar-column'>, emit: EmitType, record?: any, engine?: Engine, routeParams?: {
+    route: RouteLocationNormalizedLoaded;
+    router: Router;
+}, formModalVisible?: Ref<boolean>): {
+    viewLoading: ComputedRef<any>;
+    editLoading: ComputedRef<any>;
+    menuVisible: Ref<boolean>;
+    handleViewRow: (instanceProps: any, formObj: any) => Promise<void>;
+    handleEditRow: (instanceProps: any, formObj: any) => Promise<void>;
+    handleRow: (type: BTN_TYPE, instanceProps: any, tagIndex?: number) => void;
+};

package/dist/src/hooks/controls/listView/useQuerySelectedRows.d.ts

@@ -1,19 +1,15 @@
-import { Ref, ComputedRef } from 'vue';
 import { Engine } from '@byteluck-fe/model-driven-engine';
+import { Ref, ComputedRef } from 'vue';
+
 /**
  * 【【表单】【地平线】希望列表选择跨页优化】https://www.tapd.cn/67265839/prong/stories/view/1167265839001010505
  * @param context
  * @returns
  */
-export declare function useQuerySelectedRows(tableid: string, selectState: {
-    selectedRowKeys: string[];
-    selectedRows: any[];
-}, context?: Engine, primaryKey?: string): {
-    selectState: {
-        selectedRowKeys: string[];
-        selectedRows: any[];
-    };
+export declare function useQuerySelectedRows(props: any, context?: Engine, primaryKey?: string): {
     isQuerySelectedRows: Ref<boolean>;
+    clearAllSelect: () => void;
+    clickDelIcon: (id: string) => void;
     querySelectedRows: (args: any) => void;
-    selectedCount: ComputedRef<number>;
+    selectedCount: ComputedRef<any>;
 };

package/dist/src/hooks/controls/listView/useRowSpanModel.d.ts

@@ -0,0 +1,5 @@
+import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
+
+export declare function checkToGenerateRowSpan(rows: any[], instance: ControlRuntimeInstance<'list-view'>): void;
+export declare function generateSymbolIndexList(rows: any[], instance: ControlRuntimeInstance<'list-view'>): number[] | undefined;
+export declare function getTableHeadersModelTypeData(listViewInstance: ControlRuntimeInstance<'list-view'>): any;

package/dist/src/hooks/controls/selecRelation/tools.d.ts

@@ -1,4 +1,4 @@
 export declare function getNoCacheListTableSchema(appId: string, formKey: string): Promise<typing.ApplyPageBo | undefined>;
-export declare function getModel(modelstring: string): any;
+export declare function getModel(result: any): any;
 export declare function getOperationSchema(model: any): any;
 export declare function getBindProcessInstanceId(result: typing.PageDataDetailBo): string | undefined;

package/dist/src/hooks/controls/selecRelation/useSelectRelationEngineInit.d.ts

@@ -1,8 +1,9 @@
+import { ShallowRef, Ref } from 'vue';
 import { Engine } from '@byteluck-fe/model-driven-engine';
-import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
-export declare function useSelectRelationEngineInit(props: {
-    instance: ControlRuntimeInstance<'select-relation'>;
-}): {
-    allFields: any;
-    onEngineInit: (engine: Engine) => void;
+import { CONTROL_TYPE, ControlPropertyInstance } from '@byteluck-fe/model-driven-core-all';
+import { PropsInstanceType } from '../../../constant';
+
+export declare function useSelectRelationEngineInit(props: PropsInstanceType<CONTROL_TYPE.SELECT_RELATION>, instanceProps: ShallowRef<ControlPropertyInstance<CONTROL_TYPE.SELECT_RELATION>>): {
+    allFields: Ref<any>;
+    onEngineInit: (engine: Engine, rowIndex?: number) => void;
 };

package/dist/src/hooks/controls/selecRelation/useViewLink.d.ts

@@ -1,4 +1,5 @@
 import { Ref } from 'vue';
+
 export declare function useViewLink(appId: string | Ref<string>, formKey: string, uId: Ref<string>, canViewForm: boolean, valueFieldCode: string, context?: any, instanceProps?: any): {
     openFormModel: Ref<{
         appId: string;

package/dist/src/hooks/controls/simpleSearch/useSimpleSearch.d.ts

@@ -1,11 +1,12 @@
-import { Rules } from 'async-validator';
-import { ShallowRef, Ref, ComputedRef } from 'vue';
+import { ComputedRef, ShallowRef, Ref } from 'vue';
 import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
 import { Engine } from '@byteluck-fe/model-driven-engine';
 import { ISearchType } from '../../../types/controls/simple-search';
+import { Rules } from 'async-validator';
+
 export default function useOperate(instance: ControlRuntimeInstance<'simple-search'>, emit: EmitType, formModel: ComputedRef<Record<string, any>>, context?: Engine): {
     handleFormData: () => Promise<false | ISearchType[]>;
-    rules: ShallowRef<Rules | undefined>;
+    rules: ShallowRef< Rules | undefined>;
     formRef: Ref<any>;
     gridTableId: Ref<string>;
     handleSubmit: () => Promise<boolean>;

package/dist/src/hooks/controls/subtable/index.d.ts

@@ -1 +1,2 @@
 export * from './useSubtableFormEngineModal';
+export * from './useSubtableInstanceSchemaChange';

package/dist/src/hooks/controls/subtable/useSubtableDelete.d.ts

@@ -1,2 +1,3 @@
 import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
+
 export declare function useGetSubtableDeleteIds(instance: ControlRuntimeInstance<'subtable'>): (selectedRows: any[], selectedRowKeys: string[]) => Promise<true | string[] | undefined>;

package/dist/src/hooks/controls/subtable/useSubtableFormEngineModal.d.ts

@@ -1,10 +1,8 @@
-import { ComputedRef, Ref } from 'vue';
+import { Ref, ComputedRef } from 'vue';
 import { Engine } from '@byteluck-fe/model-driven-engine';
 import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
-interface VirtualStoreState {
-    data_set: typing.PageDataBo;
-    subtable_data_set: typing.PageSubTableDataBo[];
-}
+import { VirtualStoreState } from '../../../constant/controls';
+
 export declare function useSubtableFormEngineModal(instance: Ref<ControlRuntimeInstance<'subtable'>>, desktop?: boolean): {
     visible: Ref<boolean>;
     formKey: ComputedRef<string>;
@@ -12,8 +10,7 @@ export declare function useSubtableFormEngineModal(instance: Ref<ControlRuntimeI
     readonly: ComputedRef<boolean>;
     isEditInModal: ComputedRef<boolean>;
     copyVirtualStore: (virtualStore: VirtualStoreState) => VirtualStoreState;
-    handlerOpenModal: (rowIndex?: number | undefined) => Promise<unknown>;
-    onEngineSubmitted: (context: Engine, payload: any) => void;
-    onEngineMounted: (context: any) => void;
+    handlerOpenModal: (rowIndex?: number) => Promise<unknown>;
+    onEngineSubmitted: (context: Engine, payload: any) => Promise<void>;
+    onEngineMounted: (context: Engine) => void;
 };
-export {};

package/dist/src/hooks/controls/tab/useTab.d.ts

@@ -0,0 +1,14 @@
+import { CONTROL_TYPE } from '@byteluck-fe/model-driven-core-all';
+import { PropsInstanceType } from '../../../constant';
+import { Ref, ComputedRef } from 'vue';
+import { Engine } from '@byteluck-fe/model-driven-engine';
+
+export declare function useTab(props: PropsInstanceType<CONTROL_TYPE.TAB>, options: {
+    lazyCount: number;
+}): {
+    activeKey: Ref<any>;
+    getState: (id: string, rowIndex?: number | undefined) => any;
+    context: Ref<Engine> | undefined;
+    lazyChildren: ComputedRef<any>;
+    onChangeTab: (key: string) => void;
+};

package/dist/src/hooks/controls/textReaderOnly/index.d.ts

@@ -0,0 +1 @@
+export * from './useDetailedList';

package/dist/src/hooks/controls/textReaderOnly/useDetailedList.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+export declare function useDetailedList(contenxt: any, controlId: string | undefined): {
+    detailListStatus: Ref<boolean>;
+};

package/dist/src/hooks/controls/title/useTitleCopyDocument.d.ts

@@ -1,7 +1,8 @@
+import { PropsInstanceType } from '../../../constant';
+import { CONTROL_TYPE } from '@byteluck-fe/model-driven-core-all';
 import { ComputedRef } from 'vue';
-export declare function useTitleCopyDocument(props: {
-    value: Recordable<any>;
-}, thirdComponent?: Recordable<any>): {
+
+export declare function useTitleCopyDocument(props: PropsInstanceType<CONTROL_TYPE.TITLE>, thirdComponent?: Recordable<any>): {
     canCopy: ComputedRef<any>;
     copyDocument: () => Promise<void>;
 };

package/dist/src/hooks/controls/useDateRange.d.ts

@@ -0,0 +1,137 @@
+import { ShallowRef, Ref, ComputedRef } from 'vue';
+import { ControlPropertyInstance, ControlRuntimeInstance, LimitDate } from '@byteluck-fe/model-driven-core-all';
+
+export declare function useDateRange(instanceProps: ShallowRef<ControlPropertyInstance<'date-range' | 'date-picker' | 'search-date-range'>>, instance: ControlRuntimeInstance<'date-range' | 'date-picker' | 'search-date-range'>): {
+    minDate: Ref<{
+        toString: () => string;
+        toDateString: () => string;
+        toTimeString: () => string;
+        toLocaleString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleDateString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleTimeString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        valueOf: () => number;
+        getTime: () => number;
+        getFullYear: () => number;
+        getUTCFullYear: () => number;
+        getMonth: () => number;
+        getUTCMonth: () => number;
+        getDate: () => number;
+        getUTCDate: () => number;
+        getDay: () => number;
+        getUTCDay: () => number;
+        getHours: () => number;
+        getUTCHours: () => number;
+        getMinutes: () => number;
+        getUTCMinutes: () => number;
+        getSeconds: () => number;
+        getUTCSeconds: () => number;
+        getMilliseconds: () => number;
+        getUTCMilliseconds: () => number;
+        getTimezoneOffset: () => number;
+        setTime: (time: number) => number;
+        setMilliseconds: (ms: number) => number;
+        setUTCMilliseconds: (ms: number) => number;
+        setSeconds: (sec: number, ms?: number | undefined) => number;
+        setUTCSeconds: (sec: number, ms?: number | undefined) => number;
+        setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setDate: (date: number) => number;
+        setUTCDate: (date: number) => number;
+        setMonth: (month: number, date?: number | undefined) => number;
+        setUTCMonth: (month: number, date?: number | undefined) => number;
+        setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        toUTCString: () => string;
+        toISOString: () => string;
+        toJSON: (key?: any) => string;
+        [Symbol.toPrimitive]: {
+            (hint: "default"): string;
+            (hint: "string"): string;
+            (hint: "number"): number;
+            (hint: string): string | number;
+        };
+    }>;
+    maxDate: Ref<{
+        toString: () => string;
+        toDateString: () => string;
+        toTimeString: () => string;
+        toLocaleString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleDateString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleTimeString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        valueOf: () => number;
+        getTime: () => number;
+        getFullYear: () => number;
+        getUTCFullYear: () => number;
+        getMonth: () => number;
+        getUTCMonth: () => number;
+        getDate: () => number;
+        getUTCDate: () => number;
+        getDay: () => number;
+        getUTCDay: () => number;
+        getHours: () => number;
+        getUTCHours: () => number;
+        getMinutes: () => number;
+        getUTCMinutes: () => number;
+        getSeconds: () => number;
+        getUTCSeconds: () => number;
+        getMilliseconds: () => number;
+        getUTCMilliseconds: () => number;
+        getTimezoneOffset: () => number;
+        setTime: (time: number) => number;
+        setMilliseconds: (ms: number) => number;
+        setUTCMilliseconds: (ms: number) => number;
+        setSeconds: (sec: number, ms?: number | undefined) => number;
+        setUTCSeconds: (sec: number, ms?: number | undefined) => number;
+        setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setDate: (date: number) => number;
+        setUTCDate: (date: number) => number;
+        setMonth: (month: number, date?: number | undefined) => number;
+        setUTCMonth: (month: number, date?: number | undefined) => number;
+        setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        toUTCString: () => string;
+        toISOString: () => string;
+        toJSON: (key?: any) => string;
+        [Symbol.toPrimitive]: {
+            (hint: "default"): string;
+            (hint: "string"): string;
+            (hint: "number"): number;
+            (hint: string): string | number;
+        };
+    }>;
+    disabledDates: {
+        min: Date;
+        max: Date;
+    }[];
+    limitDateList: ComputedRef< LimitDate[]>;
+    instanceProps: ShallowRef<ControlPropertyInstance<"date-picker" | "date-range" | "search-date-range">>;
+};

package/dist/src/hooks/controls/useForceUpdate.d.ts

@@ -1,3 +1,4 @@
 import { EventPayload } from '@byteluck-fe/model-driven-engine';
 import { ControlRuntimeInstance, ControlsKeys } from '@byteluck-fe/model-driven-core-all';
+
 export declare function useForceUpdate(instance: MayBeRef<ControlRuntimeInstance<ControlsKeys>>, callback: (payload: EventPayload) => void): void;