@skyworx/dynamic-ui 1.0.6 → 1.0.8

package/dist/types/components/ui/tooltip/Tooltip.vue.d.ts

@@ -0,0 +1,17 @@
+import type { TooltipRootProps } from "reka-ui";
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TooltipRootProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<TooltipRootProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ui/tooltip/TooltipContent.vue.d.ts

@@ -0,0 +1,25 @@
+import type { TooltipContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+type __VLS_Props = TooltipContentProps & {
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: Event) => any) | undefined;
+}>, {
+    sideOffset: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ui/tooltip/TooltipProvider.vue.d.ts

@@ -0,0 +1,13 @@
+import type { TooltipProviderProps } from "reka-ui";
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TooltipProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ui/tooltip/TooltipTrigger.vue.d.ts

@@ -0,0 +1,13 @@
+import type { TooltipTriggerProps } from "reka-ui";
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TooltipTriggerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ui/tooltip/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Tooltip } from "./Tooltip.vue";
+export { default as TooltipContent } from "./TooltipContent.vue";
+export { default as TooltipProvider } from "./TooltipProvider.vue";
+export { default as TooltipTrigger } from "./TooltipTrigger.vue";

package/dist/types/composables/dynamic-form/actions/useFormActions.d.ts

@@ -0,0 +1,10 @@
+import { UseFormActionsOptions } from "../../../types/dynamic.types.ts";
+export declare function useFormActions({ state, props, emit, apiUrl, router, locale, mapping, validation, fieldMap, activeSchema, resolvedBaseUrl, resolveKeyParams, navigation, logic, }: UseFormActionsOptions): {
+    isActionVisible: (action: any) => boolean | undefined;
+    handleGlobalButtonClick: (action: any) => void;
+    confirmAction: () => void;
+    performAction: (action: any) => Promise<void>;
+    handleSubmit: () => Promise<void>;
+    handleCancel: () => any;
+    handleFieldUpdate: (model: string, value: any, sectionKey?: string) => void;
+};

package/dist/types/composables/dynamic-form/logic/operators.d.ts

@@ -0,0 +1 @@
+export declare function initCustomOperators(): void;

package/dist/types/composables/dynamic-form/logic/useFormLogic.d.ts

@@ -0,0 +1,28 @@
+import type { UseFormLogicOptions } from "../../../types/dynamic.types";
+export declare function useFormLogic({ formData, errors, fieldMap, rawItemsCache, activeSchema, locale, tableRowFormData, revealedSectionIds, revealedFieldModels, parentFormData: parentOption, rootFormData: rootOption, activeTableAction, activeTableRow, activeTableKey: activeTableKeyOption, tableRows: tableRowsOption, }: UseFormLogicOptions): {
+    normalizedData: import("vue").ComputedRef<Record<string, any>>;
+    getNormalizedData: (data: Record<string, any>, contextPath?: string, debugTag?: string) => Record<string, any>;
+    evaluateLogic: (rule: any, customData?: Record<string, any>, debugTag?: string, contextPath?: string) => any;
+    resolveActiveRule: (rules: any, data: Record<string, any>, debugTag: any, contextPath?: string) => any;
+    resolveValueIdentifier: (modelName: string, value: any, fieldOverride?: any, contextObj?: any) => any;
+    getFilteredItems: (field: any, customData?: Record<string, any>, contextPath?: string) => any[];
+    isFieldVisible: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldRequired: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldDisabled: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldReadonly: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldHidden: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isSectionVisible: (section: any, customData?: Record<string, any>) => boolean;
+    isSectionHidden: (section: any, customData?: Record<string, any>) => boolean;
+    resolveSectionLabels: (section: any) => {
+        title: any;
+        description: any;
+    };
+    resolveFieldLabels: (field: any, customData?: Record<string, any>) => any;
+    resolveFieldLength: (field: any, customData?: Record<string, any>) => any;
+    resolveDefaultValue: (field: any, customData?: Record<string, any>, contextPath?: string) => any;
+    getWizardTabs: (section: any) => any;
+    applyCalculations: () => void;
+    isSubmitDisabled: import("vue").ComputedRef<any>;
+    resolveSectionGridClass: (layout: any) => string;
+    resolveFieldColumnClass: (field: any, parentLayout?: string) => string;
+};

package/dist/types/composables/dynamic-form/mapping/useFormMapping.d.ts

@@ -0,0 +1,3 @@
+import { MappingComposables } from "../types/form.types";
+import { UseFormMappingOptions } from "../../../types/dynamic.types";
+export declare function useFormMapping({ formData, activeSchema, isSectionVisible, isFieldVisible, isFieldHidden, getWizardTabs, fieldMap, rawItemsCache, navigation, }: UseFormMappingOptions): MappingComposables;

package/dist/types/composables/dynamic-form/navigation/navigation.types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Navigation Types
+ * Type definitions for section navigation feature
+ */
+/**
+ * Configuration for back button appearance and behavior
+ */
+export interface BackButtonConfig {
+    labelEN?: string;
+    labelID?: string;
+    labelKR?: string;
+    icon?: string;
+    variant?: string;
+    position?: 'left' | 'right';
+}
+/**
+ * A single navigation rule with condition + target + hidden rules
+ */
+export interface NavigationRule {
+    id: string;
+    condition?: any;
+    targetSection: string;
+    hiddenRules: Record<string, boolean | any>;
+    parentRowContext?: {
+        parentArrayKey: string;
+        childArrayKey: string;
+    };
+}
+/**
+ * Configuration for navigation trigger on action buttons
+ * Supports both single-target (legacy) and multi-rule navigation
+ */
+export interface NavigationConfig {
+    targetSection: string;
+    hiddenRules: Record<string, boolean | any>;
+    condition?: any;
+    rules?: NavigationRule[];
+    enableBackButton?: boolean;
+    backButtonPosition?: 'header' | 'footer' | 'both';
+    backButtonConfig?: BackButtonConfig;
+    preserveData?: boolean;
+    parentRowContext?: {
+        parentArrayKey: string;
+        childArrayKey: string;
+    };
+}
+/**
+ * Item in navigation history stack
+ */
+export interface NavigationHistoryItem {
+    sectionKey: string;
+    hiddenStates: Record<string, boolean>;
+    timestamp: number;
+    sourceAction?: string;
+    context?: any;
+    backButtonConfig?: BackButtonConfig;
+}
+/**
+ * Current navigation state
+ */
+export interface NavigationState {
+    currentContext: string | null;
+    history: NavigationHistoryItem[];
+    hiddenStates: Record<string, boolean>;
+    navigationEnabled: Set<string>;
+    maxHistoryDepth: number;
+    parentRowContext?: {
+        parentArrayKey: string;
+        rowIndex: number;
+        childArrayKey: string;
+    } | null;
+}
+/**
+ * Options for useFormNavigation composable
+ */
+export interface UseFormNavigationOptions {
+    initialHiddenStates?: Record<string, boolean>;
+    maxHistoryDepth?: number;
+    debug?: boolean;
+}

package/dist/types/composables/dynamic-form/navigation/useFormNavigation.d.ts

@@ -0,0 +1,93 @@
+/**
+ * useFormNavigation - Section Navigation State Management
+ * Handles navigation between sections with history stack and back button support
+ */
+import { Ref } from "vue";
+import type { NavigationConfig, NavigationState, BackButtonConfig, UseFormNavigationOptions } from "./navigation.types";
+export declare function useFormNavigation(options?: UseFormNavigationOptions, evaluateLogic?: (rule: any, data?: any) => any, lookupSection?: (sectionKey: string) => any): {
+    navigationState: Ref<{
+        currentContext: string | null;
+        history: {
+            sectionKey: string;
+            hiddenStates: Record<string, boolean>;
+            timestamp: number;
+            sourceAction?: string | undefined;
+            context?: any;
+            backButtonConfig?: {
+                labelEN?: string | undefined;
+                labelID?: string | undefined;
+                labelKR?: string | undefined;
+                icon?: string | undefined;
+                variant?: string | undefined;
+                position?: "left" | "right" | undefined;
+            } | undefined;
+        }[];
+        hiddenStates: Record<string, boolean>;
+        navigationEnabled: Set<string> & Omit<Set<string>, keyof Set<any>>;
+        maxHistoryDepth: number;
+        parentRowContext?: {
+            parentArrayKey: string;
+            rowIndex: number;
+            childArrayKey: string;
+        } | null | undefined;
+    }, NavigationState | {
+        currentContext: string | null;
+        history: {
+            sectionKey: string;
+            hiddenStates: Record<string, boolean>;
+            timestamp: number;
+            sourceAction?: string | undefined;
+            context?: any;
+            backButtonConfig?: {
+                labelEN?: string | undefined;
+                labelID?: string | undefined;
+                labelKR?: string | undefined;
+                icon?: string | undefined;
+                variant?: string | undefined;
+                position?: "left" | "right" | undefined;
+            } | undefined;
+        }[];
+        hiddenStates: Record<string, boolean>;
+        navigationEnabled: Set<string> & Omit<Set<string>, keyof Set<any>>;
+        maxHistoryDepth: number;
+        parentRowContext?: {
+            parentArrayKey: string;
+            rowIndex: number;
+            childArrayKey: string;
+        } | null | undefined;
+    }>;
+    hasHistory: import("vue").ComputedRef<boolean>;
+    currentContext: import("vue").ComputedRef<string | null>;
+    history: import("vue").ComputedRef<{
+        sectionKey: string;
+        hiddenStates: Record<string, boolean>;
+        timestamp: number;
+        sourceAction?: string | undefined;
+        context?: any;
+        backButtonConfig?: {
+            labelEN?: string | undefined;
+            labelID?: string | undefined;
+            labelKR?: string | undefined;
+            icon?: string | undefined;
+            variant?: string | undefined;
+            position?: "left" | "right" | undefined;
+        } | undefined;
+    }[]>;
+    hiddenStates: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    parentRowContext: import("vue").ComputedRef<{
+        parentArrayKey: string;
+        rowIndex: number;
+        childArrayKey: string;
+    } | null | undefined>;
+    navigateTo: (config: NavigationConfig, context?: any) => void;
+    navigateBack: () => void;
+    applyHiddenRules: (rules: Record<string, boolean | any>, context?: any) => void;
+    getCurrentBackButton: () => BackButtonConfig | null;
+    isSectionHidden: (sectionKey: string) => boolean;
+    setSectionHidden: (sectionKey: string, hidden: boolean) => void;
+    clearHistory: () => void;
+    reset: () => void;
+    registerNavigationSection: (sectionKey: string) => void;
+};

package/dist/types/composables/dynamic-form/state/useFormState.d.ts

@@ -0,0 +1,2 @@
+import { FormState } from "../types/form.types";
+export declare function useFormState(): FormState;

package/dist/types/composables/dynamic-form/table/useFormTable.d.ts

@@ -0,0 +1,43 @@
+import { UseFormTableOptions } from "../../../types/dynamic.types";
+export declare function useFormTable(options: UseFormTableOptions): {
+    tableDialogOpen: import("vue").Ref<boolean, boolean>;
+    tableDialogTitle: import("vue").Ref<string, string>;
+    tableDialogIcon: import("vue").Ref<string, string>;
+    tableDialogFields: import("vue").Ref<any[], any[]>;
+    tableRowFormData: any;
+    tableRowErrors: Record<string, string>;
+    activeTableKey: import("vue").Ref<string, string>;
+    editingRowIndex: import("vue").Ref<number | null, number | null>;
+    tableDialogViewOnly: import("vue").Ref<boolean, boolean>;
+    confirmDeletePending: import("vue").Ref<{
+        propsTable: any;
+        row: any;
+    } | null, {
+        propsTable: any;
+        row: any;
+    } | {
+        propsTable: any;
+        row: any;
+    } | null>;
+    confirmDeleteOpen: import("vue").Ref<boolean, boolean>;
+    tableDialogSize: import("vue").Ref<string, string>;
+    isTemporaryTable: (pt: any) => boolean;
+    isActionViewOnly: (action: any) => any;
+    tableRows: (pt: any) => any[];
+    resolveTableFields: (pt: any) => any[];
+    confirmTableDelete: (pt: any, row: any) => void;
+    executeTableDelete: () => void;
+    handleTableRowUpdate: (model: string, value: any) => void;
+    openTableRowDialog: (pt: any, tAction: any, rowData?: any) => void;
+    handleDataTableAction: (pt: any, payload: {
+        action: string;
+        row: any;
+        selection?: any[];
+        isLocalSave?: boolean;
+        modelDatatable?: string;
+        actionType?: string;
+        originalRow?: any;
+        rowIndex?: number | null;
+    }) => void;
+    saveTableRow: () => void;
+};

package/dist/types/composables/dynamic-form/types/form.types.d.ts

@@ -0,0 +1,202 @@
+import { ComputedRef, Ref } from "vue";
+export interface DynamicFormProps {
+    schema: any;
+    model?: Record<string, any>;
+    isEditMode?: boolean;
+    loading?: boolean;
+    baseUrl?: string;
+    selectedTokenCore?: any;
+    tokenCores?: any[];
+    dummyMode?: boolean;
+    router?: any;
+    permissionBase?: string;
+    userPermissions?: any;
+    checkPermission?: (permission: string) => boolean;
+    dynamicForm?: any;
+    hideActions?: boolean;
+    apiParams?: Record<string, any>;
+}
+export interface FormState {
+    revision: Ref<number>;
+    formData: Record<string, any>;
+    originalData: Record<string, any>;
+    tableRowFormData: Record<string, any>;
+    errors: Record<string, string>;
+    touched: Record<string, boolean>;
+    isSubmitted: Ref<boolean>;
+    fieldErrors: Record<string, string | null>;
+    wizardState: Record<string, number>;
+    inlineState: Record<string, boolean>;
+    isSubmitting: Ref<boolean>;
+    internalSchema: Ref<any>;
+    rawItemsCache: Record<string, any[]>;
+    revealedSectionIds: Record<string, boolean>;
+    revealedFieldModels: Record<string, boolean>;
+    wizardResponses: Record<string, any>;
+    sectionLoading: Record<string, boolean>;
+    fieldLoading: Record<string, boolean>;
+    sectionPagination: Record<string, {
+        page: number;
+        perPage: number;
+        totalData?: number;
+        maxPage?: number;
+        filters?: Record<string, any>;
+    }>;
+    confirmDialog: {
+        visible: boolean;
+        title: string;
+        message: string;
+        action: any;
+        showCancel?: boolean;
+        okText?: string;
+        cancelText?: string;
+        isBlocking?: boolean;
+        redirectUrl?: string;
+    };
+    activeTableAction?: Ref<any>;
+    activeTableKey?: Ref<string>;
+}
+export interface FieldMapEntry {
+    field: any;
+    path: string;
+}
+export interface FieldMap {
+    paths: Map<string, FieldMapEntry>;
+    models: Map<string, FieldMapEntry[]>;
+}
+export interface LogicComposables {
+    normalizedData: ComputedRef<any>;
+    getNormalizedData: (data: Record<string, any>, contextPath?: string) => any;
+    evaluateLogic: (rule: any, data: Record<string, any>, debugTag?: string, contextPath?: string) => any;
+    resolveActiveRule: (rules: any, data: Record<string, any>, debugTag: any, contextPath?: string) => any;
+    resolveValueIdentifier: (modelName: string, value: any, fieldOverride?: any, contextObj?: any) => any;
+    getFilteredItems: (field: any, customData?: Record<string, any>) => any[];
+    isFieldVisible: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldRequired: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldDisabled: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldReadonly: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldHidden: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    resolveSectionLabels: (section: any) => {
+        title: string;
+        description: string;
+    };
+    isSectionVisible: (section: any, customData?: Record<string, any>) => boolean;
+    isSectionHidden: (section: any, customData?: Record<string, any>) => boolean;
+    resolveFieldLabels: (field: any, customData?: Record<string, any>) => any;
+    resolveFieldLength: (field: any, customData?: Record<string, any>) => any;
+    resolveDefaultValue: (field: any, customData?: Record<string, any>, contextPath?: string) => any;
+    getWizardTabs: (section: any) => any[];
+    applyCalculations: () => void;
+    isSubmitDisabled: ComputedRef<boolean>;
+    resolveSectionGridClass: (layout: any) => string;
+    resolveFieldColumnClass: (field: any, parentLayout?: string) => string;
+}
+export interface ValidationComposables {
+    validateField: (field: any, val: any, customData?: Record<string, any>) => string | null;
+    validateAll: () => boolean;
+}
+export interface FormArrayModel {
+    key: string;
+    subFields: string[];
+}
+export interface MappingComposables {
+    getCleanPayload: () => Record<string, any>;
+    applyFieldMapping: (data: Record<string, any>, mapping: Record<string, any>) => Record<string, any>;
+    handleResponseMapping: (res: any, mapping: Record<string, any>, basePath?: string) => void;
+    handleClearMapping: (mapping: Record<string, any>, basePath?: string) => void;
+    getFormArrayModels: () => FormArrayModel[];
+}
+export interface UseFormWatcherOptions {
+    state: FormState;
+    props: DynamicFormProps;
+    emit: any;
+    logic: LogicComposables;
+    mapping: MappingComposables;
+    activeSchema: ComputedRef<any>;
+    fieldMap: ComputedRef<FieldMap>;
+    prefetchFieldItems: (field: any, force?: boolean, contextPath?: string, localData?: any) => Promise<void>;
+    triggerFetchRule: (field: any, rule: any, contextPath?: string, localData?: any) => Promise<void>;
+    fetchSectionData: (sectionKey: string, sectionObj?: any, contextPathOverride?: string) => Promise<void>;
+    router?: any;
+}
+export interface UseFormActionsOptions {
+    state: FormState;
+    props: DynamicFormProps;
+    emit: any;
+    apiUrl: any;
+    router: any;
+    locale: ComputedRef<string>;
+    mapping: MappingComposables;
+    validation: ValidationComposables;
+    fieldMap: ComputedRef<FieldMap>;
+    activeSchema: ComputedRef<any>;
+    resolvedBaseUrl: ComputedRef<string | undefined>;
+    resolveKeyParams?: any;
+    navigation?: any;
+    logic?: LogicComposables;
+}
+export interface UseFormLogicOptions {
+    formData: Record<string, any>;
+    tableRowFormData?: Record<string, any>;
+    errors: Record<string, string>;
+    fieldMap: ComputedRef<FieldMap>;
+    rawItemsCache: Record<string, any[]>;
+    activeSchema: ComputedRef<any>;
+    locale: ComputedRef<string>;
+    revealedSectionIds?: Record<string, boolean>;
+    revealedFieldModels?: Record<string, boolean>;
+    parentFormData?: Record<string, any>;
+    rootFormData?: Record<string, any>;
+    activeTableAction?: Ref<any>;
+    activeTableRow?: Ref<any>;
+    activeTableKey?: Ref<string>;
+    tableRows?: ComputedRef<any[]> | Ref<any[]> | any[];
+}
+export interface UseFormMappingOptions {
+    formData: Record<string, any>;
+    activeSchema: ComputedRef<any>;
+    isSectionVisible: (section: any, customData?: Record<string, any>) => boolean;
+    isFieldVisible: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldHidden: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    getWizardTabs: (section: any) => any[];
+    fieldMap: ComputedRef<FieldMap>;
+    rawItemsCache: Record<string, any[]>;
+    navigation?: any;
+}
+export interface UseFormTableOptions {
+    formData: Record<string, any>;
+    validation: ValidationComposables;
+    locale: ComputedRef<string>;
+    emit: any;
+    mapping: MappingComposables;
+    logic?: any;
+    state?: any;
+    activeSchema?: ComputedRef<any>;
+    prefetchFieldItems?: (field: any, force?: boolean, contextPath?: string, localData?: any) => Promise<void>;
+    triggerFetchRule?: (field: any, rule: any, contextPath?: string, localData?: any) => Promise<void>;
+    navigation?: any;
+}
+export interface UseFormValidationOptions {
+    formData: Record<string, any>;
+    locale: ComputedRef<string>;
+    errors: Record<string, string>;
+    fieldMap: ComputedRef<FieldMap>;
+    activeSchema: ComputedRef<any>;
+    isSectionVisible: (section: any, customData?: Record<string, any>) => boolean;
+    isSectionHidden?: (section: any, customData?: Record<string, any>) => boolean;
+    isFieldVisible: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldRequired: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    resolveFieldLength: (field: any, customData?: Record<string, any>) => any;
+}
+export interface DynamicFormContext {
+    formData: Record<string, any>;
+    originalData: Record<string, any>;
+    locale: ComputedRef<string>;
+    errors: Record<string, string>;
+    isSubmitted: Ref<boolean>;
+    fieldMap: ComputedRef<FieldMap>;
+    activeSchema: ComputedRef<any>;
+    resolvedBaseUrl: ComputedRef<string | undefined>;
+    resolveKeyParams?: any;
+    navigation?: any;
+}