@form-eng/core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1457 @@
+import * as react_hook_form from 'react-hook-form';
+import { FieldError, UseFormSetValue } from 'react-hook-form';
+import React from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/** Dropdown/select option */
+interface IOption {
+    /** The option value (used for selection state) */
+    value: string | number;
+    /** Display label shown to the user */
+    label: string;
+    /** Whether this option is disabled (visible but not selectable) */
+    disabled?: boolean;
+    /** Grouping label for option groups (e.g., select optgroup) */
+    group?: string;
+    /** Icon identifier for rendering alongside the label */
+    icon?: string;
+    /** Color indicator (e.g., for status badges) */
+    color?: string;
+}
+
+/**
+ * Condition types for the v2 rule engine.
+ *
+ * Conditions can be field-level comparisons or logical combinations (AND/OR/NOT).
+ * Used in IRule.when, IValidationRule.when, and IWizardStepCondition.
+ */
+/** A condition that compares a single field's value */
+interface IFieldCondition {
+    /** The field name to evaluate */
+    field: string;
+    /** Comparison operator */
+    operator: "equals" | "notEquals" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual" | "contains" | "notContains" | "startsWith" | "endsWith" | "in" | "notIn" | "isEmpty" | "isNotEmpty" | "matches";
+    /** The value to compare against. Not required for isEmpty/isNotEmpty. */
+    value?: unknown;
+}
+/** A logical combination of conditions */
+interface ILogicalCondition {
+    /** Logical operator to combine child conditions */
+    operator: "and" | "or" | "not";
+    /** Child conditions to combine */
+    conditions: ICondition[];
+}
+/** Union type: either a field comparison or a logical combination */
+type ICondition = IFieldCondition | ILogicalCondition;
+/** Type guard: checks if a condition is a logical condition (and/or/not) */
+declare function isLogicalCondition(condition: ICondition): condition is ILogicalCondition;
+/** Type guard: checks if a condition is a field condition */
+declare function isFieldCondition(condition: ICondition): condition is IFieldCondition;
+
+/**
+ * Unified validation rule configuration.
+ *
+ * Handles sync, async, and cross-field validation through a single interface.
+ * Validators are resolved by name from the unified ValidationRegistry.
+ */
+interface IValidationRule {
+    /** Validator name (resolved from the unified ValidationRegistry) */
+    name: string;
+    /** Parameters passed to the validator function */
+    params?: Record<string, unknown>;
+    /** Custom error message (overrides the validator's default) */
+    message?: string;
+    /** Whether this validator is async (returns a Promise) */
+    async?: boolean;
+    /** Debounce delay in ms for async validators */
+    debounceMs?: number;
+    /** Conditional validation: only run when this condition is met */
+    when?: ICondition;
+}
+
+/**
+ * Effects applied by a rule when its condition is met (or in the else branch).
+ *
+ * Any property set here overrides the field's base config.
+ * The `fields` property can affect OTHER fields (cross-field effects).
+ */
+interface IFieldEffect {
+    /** Override required state */
+    required?: boolean;
+    /** Override hidden state */
+    hidden?: boolean;
+    /** Override readOnly state */
+    readOnly?: boolean;
+    /** Override field label */
+    label?: string;
+    /** Swap the component type (preferred over component) */
+    type?: string;
+    /** Swap the component type (deprecated, use type instead) */
+    component?: string;
+    /** Replace dropdown options */
+    options?: IOption[];
+    /** Replace validation rules */
+    validate?: IValidationRule[];
+    /** Override computed value expression */
+    computedValue?: string;
+    /** Override field ordering */
+    fieldOrder?: string[];
+    /** Apply effects to OTHER fields (keyed by field name) */
+    fields?: Record<string, IFieldEffect>;
+}
+
+/**
+ * A declarative rule that conditionally modifies field state.
+ *
+ * Rules replace the v1 dependencies, dependencyRules, dropdownDependencies,
+ * and orderDependencies with a single unified system.
+ */
+interface IRule {
+    /** Optional rule identifier (for debugging/tracing) */
+    id?: string;
+    /** Condition that determines whether this rule fires */
+    when: ICondition;
+    /** Effects applied when the condition is true */
+    then: IFieldEffect;
+    /** Effects applied when the condition is false */
+    else?: IFieldEffect;
+    /** Priority for conflict resolution (higher = wins). Default: 0. */
+    priority?: number;
+}
+
+/**
+ * Static configuration for a single form field (v2 schema).
+ *
+ * This is the primary consumer-facing type used to define forms.
+ * All dependency, validation, and state-management concerns use
+ * the unified `rules` and `validate` arrays.
+ */
+interface IFieldConfig {
+    /** UI component type key (e.g., "Textbox", "Dropdown", "Toggle"). Must match a registered component. */
+    type: string;
+    /** Display label for the field (required in v2). */
+    label: string;
+    /** Whether the field is required for form submission. Can be overridden by rules. */
+    required?: boolean;
+    /** Whether the field is hidden by default. Can be toggled by rules. */
+    hidden?: boolean;
+    /** Whether the field is read-only (rendered but not editable). Can be toggled by rules. */
+    readOnly?: boolean;
+    /** Default value applied when the field is visible and its current value is null/undefined. */
+    defaultValue?: unknown;
+    /** Computed value expression. Uses $values.fieldName for references, $fn.name() for value functions. */
+    computedValue?: string;
+    /** If true, computedValue only runs during create (not edit). */
+    computeOnCreateOnly?: boolean;
+    /** Static dropdown/select options. */
+    options?: IOption[];
+    /** Validation rules (unified: sync, async, cross-field, conditional). */
+    validate?: IValidationRule[];
+    /** Business rules (unified: replaces dependencies, dependencyRules, dropdownDependencies, orderDependencies). */
+    rules?: IRule[];
+    /** Field array item configs (full IFieldConfig, not stripped). Keys are field names within an item. */
+    items?: Record<string, IFieldConfig>;
+    /** Minimum number of items in a field array. */
+    minItems?: number;
+    /** Maximum number of items in a field array. */
+    maxItems?: number;
+    /** Arbitrary metadata passed through to the field component (e.g., icons, sort settings). */
+    config?: Record<string, unknown>;
+    /** Short description shown as field tooltip or help text. */
+    description?: string;
+    /** Placeholder text for empty fields. */
+    placeholder?: string;
+    /** Extended help text (e.g., shown in a popover or below the field). */
+    helpText?: string;
+    /** Whether changing this field triggers a confirmation modal before save. */
+    confirmInput?: boolean;
+    /** If true, the field is not rendered when the form is in create mode. */
+    hideOnCreate?: boolean;
+    /** If true, the field ignores the layout-level disabled/readOnly override. */
+    skipLayoutReadOnly?: boolean;
+    /** Whether the field is disabled at the layout level. */
+    disabled?: boolean;
+}
+
+/** Configuration for a single wizard step */
+interface IWizardStep {
+    /** Unique step identifier */
+    id: string;
+    /** Step title displayed to the user */
+    title: string;
+    /** Optional step description */
+    description?: string;
+    /** Field names included in this step */
+    fields: string[];
+    /** Condition under which this step is visible (uses v2 condition system) */
+    visibleWhen?: ICondition;
+}
+/** Wizard configuration */
+interface IWizardConfig {
+    /** Step definitions */
+    steps: IWizardStep[];
+    /** If true, users must complete steps in order (no skipping ahead) */
+    linearNavigation?: boolean;
+    /** If true, validate the current step before allowing navigation */
+    validateOnStepChange?: boolean;
+    /** If true, save form data when navigating between steps */
+    saveOnStepChange?: boolean;
+}
+
+/**
+ * Analytics/telemetry callback hooks for form lifecycle events.
+ *
+ * All callbacks are optional -- if not provided, the corresponding events are silently ignored.
+ */
+interface IAnalyticsCallbacks {
+    /** Fired when a field receives focus. */
+    onFieldFocus?: (fieldName: string) => void;
+    /** Fired when a field loses focus. `timeSpentMs` is the duration since the matching onFieldFocus. */
+    onFieldBlur?: (fieldName: string, timeSpentMs: number) => void;
+    /** Fired when a field value changes. */
+    onFieldChange?: (fieldName: string, oldValue: unknown, newValue: unknown) => void;
+    /** Fired when field validation fails. */
+    onValidationError?: (fieldName: string, errors: string[]) => void;
+    /** Fired on successful form submission. `durationMs` is elapsed time since form mount. */
+    onFormSubmit?: (values: Record<string, unknown>, durationMs: number) => void;
+    /** Fired when the user navigates away with unsaved changes. */
+    onFormAbandonment?: (filledFields: string[], emptyRequiredFields: string[]) => void;
+    /** Fired when the wizard step changes. */
+    onWizardStepChange?: (fromStep: number, toStep: number) => void;
+    /** Fired when a rule is evaluated. */
+    onRuleTriggered?: (event: {
+        fieldName: string;
+        ruleIndex: number;
+        conditionMet: boolean;
+    }) => void;
+}
+
+/**
+ * Top-level form configuration (v2 schema).
+ *
+ * Wraps all field definitions, ordering, wizard config, and form-level settings
+ * into a single versioned object. This replaces the loose Dictionary<IFieldConfig> pattern.
+ */
+interface IFormConfig {
+    /** Schema version. Must be 2. */
+    version: 2;
+    /** Field definitions keyed by field name. */
+    fields: Record<string, IFieldConfig>;
+    /** Default field display order. If omitted, uses Object.keys(fields) order. */
+    fieldOrder?: string[];
+    /** Multi-step wizard configuration. */
+    wizard?: IWizardConfig;
+    /** Form-level settings. */
+    settings?: IFormSettings;
+}
+/** Form-level settings */
+interface IFormSettings {
+    /** Whether the form is in manual save mode (no auto-save on field change). */
+    manualSave?: boolean;
+    /** Timeout in ms for each save attempt. */
+    saveTimeoutMs?: number;
+    /** Maximum save retry attempts. */
+    maxSaveRetries?: number;
+    /** Number of visible fields before collapse. */
+    expandCutoffCount?: number;
+    /** Max height in px when collapsed. */
+    collapsedMaxHeight?: number;
+    /** Enable field filter/search input. */
+    enableFilter?: boolean;
+    /** Analytics/telemetry callbacks for form lifecycle events. */
+    analytics?: IAnalyticsCallbacks;
+}
+
+/**
+ * Props passed to injected field components (v2 schema).
+ *
+ * This replaces the v1 IHookFieldSharedProps type.
+ * The generic parameter T types the `config` metadata object.
+ */
+interface IFieldProps<T = Record<string, unknown>> {
+    /** Field name (unique identifier within the form) */
+    fieldName?: string;
+    /** Entity ID */
+    entityId?: string;
+    /** Entity type */
+    entityType?: string;
+    /** Program name */
+    programName?: string;
+    /** Parent entity ID */
+    parentEntityId?: string;
+    /** Parent entity type */
+    parentEntityType?: string;
+    /** Whether the field is read-only */
+    readOnly?: boolean;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Current field error */
+    error?: FieldError;
+    /** Total error count across all fields */
+    errorCount?: number;
+    /** Whether the field is currently saving */
+    saving?: boolean;
+    /** Whether save is pending due to errors */
+    savePending?: boolean;
+    /** Current field value */
+    value?: unknown;
+    /** Field-specific config metadata (was `meta` in v1) */
+    config?: T;
+    /** Dropdown/select options (was `dropdownOptions` in v1) */
+    options?: IOption[];
+    /** Field label */
+    label?: string;
+    /** Component type string */
+    type?: string;
+    /** Description text */
+    description?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Help text */
+    helpText?: string;
+    /** Callback to set a field's value */
+    setFieldValue?: (fieldName: string, fieldValue: unknown, skipSave?: boolean, timeout?: number) => void;
+}
+
+/**
+ * Runtime state for a single field after all rules have been evaluated.
+ *
+ * This replaces the v1 IBusinessRule type. Contains the evaluated state
+ * consumed by form components to determine rendering behavior.
+ */
+interface IRuntimeFieldState {
+    /** UI component type to render. May be swapped by rules. */
+    type?: string;
+    /** Whether the field is required for form submission. */
+    required?: boolean;
+    /** Whether the field is hidden (not rendered). Hidden fields skip validation. */
+    hidden?: boolean;
+    /** Whether the field is read-only (rendered but not editable). */
+    readOnly?: boolean;
+    /** Current validation rules (may be modified by rules). */
+    validate?: IValidationRule[];
+    /** Computed value expression (may be set by rules). */
+    computedValue?: string;
+    /** Whether changing this field triggers a confirmation modal. */
+    confirmInput?: boolean;
+    /** Available options for dropdown-type fields (may be filtered by rules). */
+    options?: IOption[];
+    /** Override field label (may be set by rules). */
+    label?: string;
+    /** Default value to set when the field value is null and the field is visible. */
+    defaultValue?: unknown;
+    /** If true, computedValue only runs during create. */
+    computeOnCreateOnly?: boolean;
+    /** Fields that this field's rules affect (forward dependencies). */
+    dependentFields?: string[];
+    /** Fields whose values affect this field (reverse dependencies). */
+    dependsOnFields?: string[];
+    /** The source rules that produced this state (for tracing/debugging). */
+    activeRuleIds?: string[];
+}
+/**
+ * Runtime state for the entire form.
+ *
+ * This replaces the v1 IConfigBusinessRules + IBusinessRulesState types.
+ */
+interface IRuntimeFormState {
+    /** Per-field runtime state keyed by field name. */
+    fieldStates: Record<string, IRuntimeFieldState>;
+    /** Current field display order. */
+    fieldOrder: string[];
+}
+/**
+ * State stored in the rules engine provider (keyed by config name).
+ *
+ * This replaces the v1 IBusinessRulesState type.
+ */
+interface IRulesEngineState {
+    configs: Record<string, IRuntimeFormState>;
+}
+
+/** Action type keys for the rules engine reducer */
+declare enum RulesEngineActionType {
+    SET = "RULES_ENGINE_SET",
+    UPDATE = "RULES_ENGINE_UPDATE",
+    CLEAR = "RULES_ENGINE_CLEAR"
+}
+interface ISetRulesAction {
+    readonly type: RulesEngineActionType.SET;
+    readonly payload: {
+        readonly configName: string;
+        readonly formState: IRuntimeFormState;
+    };
+}
+interface IUpdateRulesAction {
+    readonly type: RulesEngineActionType.UPDATE;
+    readonly payload: {
+        readonly configName: string;
+        readonly formState: IRuntimeFormState;
+    };
+}
+interface IClearRulesAction {
+    readonly type: RulesEngineActionType.CLEAR;
+    readonly payload: {
+        readonly configName?: string;
+    };
+}
+type RulesEngineAction = ISetRulesAction | IUpdateRulesAction | IClearRulesAction;
+
+/** All localizable string keys used by the core package */
+interface ICoreLocaleStrings {
+    autoSavePending: string;
+    savePending: string;
+    saving: string;
+    saveError: string;
+    save: string;
+    cancel: string;
+    create: string;
+    update: string;
+    confirm: string;
+    add: string;
+    edit: string;
+    deleteLabel: string;
+    remove: string;
+    close: string;
+    clear: string;
+    required: string;
+    remaining: string;
+    na: string;
+    unknown: string;
+    loading: string;
+    noResultsFound: string;
+    clickToClear: string;
+    linkTitleLabel: string;
+    linkUrlLabel: string;
+    urlRequired: string;
+    seeLess: string;
+    expand: string;
+    openExpandedTextEditor: string;
+    closeExpandedTextEditor: string;
+    unsavedChanges: string;
+    returnToEditing: string;
+    dontSave: string;
+    overview: string;
+    by: string;
+    filterFields: string;
+    saved: string;
+    saveFailed: string;
+    validating: string;
+    stepOf: (current: number, total: number) => string;
+    formWizard: string;
+    itemOfTotal: (index: number, total: number, label: string) => string;
+    saveChangesTo: (title: string) => string;
+    invalidUrl: string;
+    invalidEmail: string;
+    invalidPhoneNumber: string;
+    invalidYear: string;
+    contentExceedsMaxSize: (maxKb: number) => string;
+    noSpecialCharacters: string;
+    invalidCurrencyFormat: string;
+    duplicateValue: (value: string) => string;
+    mustBeAtLeastChars: (min: number) => string;
+    mustBeAtMostChars: (max: number) => string;
+    mustBeANumber: string;
+    mustBeBetween: (min: number, max: number) => string;
+    thisFieldIsRequired: string;
+    saveRetrying: string;
+    saveTimeout: string;
+    draftRecovered: string;
+    discardDraft: string;
+    unsavedChangesWarning: string;
+}
+
+/**
+ * A field config where rule targets are constrained to known field names.
+ * Provides compile-time checking that cross-field rule effects reference valid fields.
+ */
+type TypedFieldConfig<TFields extends string> = Omit<IFieldConfig, "rules"> & {
+    /**
+     * Business rules with type-safe cross-field effect targets.
+     * Field names in `then.fields` and `else.fields` are checked against TFields.
+     */
+    rules?: Array<{
+        id?: string;
+        when: ICondition;
+        then: Omit<IFieldEffect, "fields"> & {
+            fields?: Partial<Record<TFields, IFieldEffect>>;
+        };
+        else?: Omit<IFieldEffect, "fields"> & {
+            fields?: Partial<Record<TFields, IFieldEffect>>;
+        };
+        priority?: number;
+    }>;
+};
+/**
+ * Define field configs with type-safe rule references.
+ * TypeScript will error if a rule's cross-field effect targets a field name that doesn't exist.
+ *
+ * At runtime this is a no-op -- it just returns the input. The value is purely at compile time.
+ *
+ * @example
+ * const config = defineFormConfig({
+ *   name: { type: "Textbox", label: "Name" },
+ *   status: {
+ *     type: "Dropdown",
+ *     label: "Status",
+ *     options: [{ value: "Active", label: "Active" }, { value: "Inactive", label: "Inactive" }],
+ *     rules: [{
+ *       when: { field: "status", operator: "equals", value: "Active" },
+ *       then: { fields: { name: { required: true } } },  // "name" checked at compile time
+ *     }],
+ *   },
+ * });
+ */
+declare function defineFormConfig<T extends Record<string, TypedFieldConfig<Extract<keyof T, string>>>>(fields: T): Record<string, IFieldConfig>;
+
+/**
+ * Interface to track the confirm input modal props
+ */
+interface IConfirmInputModalProps {
+    /**
+     * The field that triggered the modal
+     */
+    confirmInputsTriggeredBy?: string;
+    /**
+     * The fields that need need to be updated within the Confirm Input Modal
+     */
+    dependentFieldNames?: string[];
+    /**
+     * Dirty fields that can be saved w/o confirmation
+     */
+    otherDirtyFields?: string[];
+}
+
+interface IFieldToRender {
+    /**
+     * Field Name
+     */
+    fieldName: string;
+    /**
+     * Soft Hidden means render the controller for hook forms but not the field input
+     */
+    softHidden?: boolean;
+}
+
+/** Generic dictionary type */
+type Dictionary<T> = Record<string, T>;
+/** Entity data type */
+type IEntityData = Record<string, unknown>;
+/** Sub-entity value type */
+type SubEntityType = string | number | boolean | Date | object | null | undefined;
+declare function isEmpty(value: unknown): boolean;
+declare function isNull(value: unknown): value is null | undefined;
+declare function isStringEmpty(value: string | null | undefined): boolean;
+declare function deepCopy<T>(obj: T): T;
+declare function convertBooleanToYesOrNoText(value: boolean | null | undefined): string;
+/** Sort options alphabetically by label */
+declare function sortDropdownOptions(a: {
+    label?: string;
+}, b: {
+    label?: string;
+}): number;
+/** Create an option from a value string (value and label are the same) */
+declare function createOption(value: string): {
+    value: string;
+    label: string;
+};
+
+interface IFormEngineSharedProps {
+    entityId?: string;
+    entityType?: string;
+    programName: string;
+    configName: string;
+    parentEntityId?: string;
+    parentEntityType?: string;
+    entityPath?: string;
+    areAllFieldsReadonly?: boolean;
+    expandCutoffCount?: number;
+    collapsedMaxHeight?: number;
+    isCreate?: boolean;
+    customSaveKey?: string;
+    customSaveCallbackKey?: string;
+    enableFilter?: boolean;
+    /** Current user's identifier for value functions like setLoggedInUser */
+    currentUserId?: string;
+    /** Callback when save error occurs */
+    onSaveError?: (error: string) => void;
+    /** Parent entity data for value functions like inheritFromParent */
+    parentEntity?: IEntityData;
+}
+
+declare const FIELD_PARENT_PREFIX = "Parent.";
+/** Component type constants */
+declare const ComponentTypes: {
+    readonly Textbox: "Textbox";
+    readonly Dropdown: "Dropdown";
+    readonly Toggle: "Toggle";
+    readonly Number: "Number";
+    readonly MultiSelect: "Multiselect";
+    readonly DateControl: "DateControl";
+    readonly Slider: "Slider";
+    readonly Fragment: "DynamicFragment";
+    readonly SimpleDropdown: "SimpleDropdown";
+    readonly MultiSelectSearch: "MultiSelectSearch";
+    readonly PopOutEditor: "PopOutEditor";
+    readonly RichText: "RichText";
+    readonly Textarea: "Textarea";
+    readonly DocumentLinks: "DocumentLinks";
+    readonly StatusDropdown: "StatusDropdown";
+    readonly ReadOnly: "ReadOnly";
+    readonly ReadOnlyArray: "ReadOnlyArray";
+    readonly ReadOnlyDateTime: "ReadOnlyDateTime";
+    readonly ReadOnlyCumulativeNumber: "ReadOnlyCumulativeNumber";
+    readonly ReadOnlyRichText: "ReadOnlyRichText";
+    readonly ReadOnlyWithButton: "ReadOnlyWithButton";
+    readonly ChoiceSet: "ChoiceSet";
+    readonly FieldArray: "FieldArray";
+};
+/** Form-level constants */
+declare const FormConstants: {
+    readonly defaultExpandCutoffCount: 12;
+    readonly loadingShimmerCount: 12;
+    readonly loadingFieldShimmerHeight: 32;
+    readonly na: "n/a";
+    readonly panelActionKeys: {
+        readonly cancel: "Cancel";
+        readonly close: "Close";
+        readonly create: "Create";
+        readonly update: "Update";
+    };
+    readonly urlRegex: RegExp;
+    readonly errorColor: "#a4262c";
+};
+
+/**
+ * User-facing string literals (v2).
+ * All properties resolve through the locale registry.
+ */
+declare const FormStrings: {
+    readonly autoSavePending: string;
+    readonly savePending: string;
+    readonly remaining: string;
+    readonly saving: string;
+    readonly seeLess: string;
+    readonly expand: string;
+    readonly required: string;
+    readonly save: string;
+    readonly cancel: string;
+    readonly create: string;
+    readonly update: string;
+    readonly na: string;
+    readonly saveError: string;
+    readonly confirm: string;
+    readonly linkTitleLabel: string;
+    readonly linkUrlLabel: string;
+    readonly add: string;
+    readonly edit: string;
+    readonly deleteLabel: string;
+    readonly remove: string;
+    readonly unknown: string;
+    readonly close: string;
+    readonly loading: string;
+    readonly noResultsFound: string;
+    readonly clickToClear: string;
+    readonly clear: string;
+    readonly urlRequired: string;
+    readonly openExpandedTextEditor: string;
+    readonly closeExpandedTextEditor: string;
+    readonly unsavedChanges: string;
+    readonly returnToEditing: string;
+    readonly dontSave: string;
+    readonly overview: string;
+    readonly by: string;
+    readonly filterFields: string;
+    readonly saved: string;
+    readonly saveFailed: string;
+    readonly validating: string;
+    readonly stepOf: (current: number, total: number) => string;
+    readonly formWizard: string;
+    readonly itemOfTotal: (index: number, total: number, label: string) => string;
+    readonly saveChangesTo: (title: string) => string;
+    readonly draftRecovered: string;
+    readonly discardDraft: string;
+    readonly unsavedChangesWarning: string;
+    readonly saveRetrying: string;
+    readonly saveTimeout: string;
+};
+
+interface IRulesEngineProvider {
+    rulesState: IRulesEngineState;
+    initFormState: (configName: string, defaultValues: IEntityData, fields: Record<string, IFieldConfig>, areAllFieldsReadonly?: boolean) => IRuntimeFormState;
+    processFieldChange: (entityData: IEntityData, configName: string, fieldName: string, fields: Record<string, IFieldConfig>) => void;
+    clearFormState: (configName?: string) => void;
+}
+
+declare function UseRulesEngineContext(): IRulesEngineProvider;
+declare const RulesEngineProvider: React.FC<React.PropsWithChildren<{}>>;
+
+interface IInjectedFieldProvider {
+    injectedFields: Record<string, React.JSX.Element>;
+    setInjectedFields: (injectedFields: Record<string, React.JSX.Element>) => void;
+}
+
+declare function UseInjectedFieldContext(): IInjectedFieldProvider;
+interface InjectedFieldProviderProps {
+    /** Optional initial field registry. If provided, fields are set immediately. */
+    injectedFields?: Record<string, React.JSX.Element>;
+    children?: React.ReactNode;
+}
+declare const InjectedFieldProvider: React.FC<InjectedFieldProviderProps>;
+
+/**
+ * Builds the dependency graph from field configs.
+ * Returns adjacency lists: for each field, which other fields depend on it.
+ */
+declare function buildDependencyGraph(fields: Record<string, IFieldConfig>): Record<string, Set<string>>;
+/**
+ * Topological sort of field names using Kahn's algorithm.
+ * Returns fields in dependency order. Detects cycles.
+ */
+declare function topologicalSort(graph: Record<string, Set<string>>): {
+    sorted: string[];
+    hasCycle: boolean;
+    cycleFields: string[];
+};
+/**
+ * Builds the default runtime field state from static field configs.
+ */
+declare function buildDefaultFieldStates(fields: Record<string, IFieldConfig>, areAllFieldsReadonly?: boolean): Record<string, IRuntimeFieldState>;
+/**
+ * Evaluates all rules for all fields against current values.
+ * Returns the full runtime form state.
+ */
+declare function evaluateAllRules(fields: Record<string, IFieldConfig>, values: IEntityData, areAllFieldsReadonly?: boolean): IRuntimeFormState;
+/**
+ * Evaluates rules for fields that are transitively affected by a changed field.
+ * Returns only the changed field states (incremental update).
+ */
+declare function evaluateAffectedFields(changedField: string, fields: Record<string, IFieldConfig>, values: IEntityData, currentState: IRuntimeFormState): IRuntimeFormState;
+
+/**
+ * Evaluates a condition tree against the current form values.
+ *
+ * Supports all 15 field operators and AND/OR/NOT logical operators.
+ */
+declare function evaluateCondition(condition: ICondition, values: IEntityData): boolean;
+/**
+ * Extracts all field names referenced in a condition tree.
+ */
+declare function extractConditionDependencies(condition: ICondition): string[];
+
+declare const GetChildEntity: (entityId?: string, entity?: IEntityData, entityPath?: string, idField?: string) => IEntityData | undefined;
+declare const IsExpandVisible: (fieldStates: Record<string, IRuntimeFieldState>, expandCutoffCount?: number) => boolean;
+declare const GetConfirmInputModalProps: (dirtyFieldNames: string[], fieldStates: Record<string, IRuntimeFieldState>) => IConfirmInputModalProps;
+interface IExecuteComputedValue {
+    fieldName: string;
+    expression: string;
+}
+declare const GetComputedValuesOnDirtyFields: (dirtyFieldNames: string[], fieldStates: Record<string, IRuntimeFieldState>) => IExecuteComputedValue[];
+declare const GetComputedValuesOnCreate: (fieldStates: Record<string, IRuntimeFieldState>) => IExecuteComputedValue[];
+declare const ExecuteComputedValue: (expression: string, values: IEntityData, fieldName?: string, parentEntity?: IEntityData, currentUserId?: string) => SubEntityType;
+declare const CheckFieldValidationRules: (value: unknown, fieldName: string, entityData: IEntityData, state: IRuntimeFieldState) => string | undefined;
+declare const CheckAsyncFieldValidationRules: (value: unknown, fieldName: string, entityData: IEntityData, state: IRuntimeFieldState, signal?: AbortSignal) => Promise<string | undefined>;
+declare const CheckValidDropdownOptions: (fieldStates: Record<string, IRuntimeFieldState>, formValues: IEntityData, setValue: UseFormSetValue<IEntityData>) => void;
+declare const CheckDefaultValues: (fieldStates: Record<string, IRuntimeFieldState>, formValues: IEntityData, setValue: UseFormSetValue<IEntityData>) => void;
+declare const InitOnCreateFormState: (configName: string, fields: Record<string, IFieldConfig>, defaultValues: IEntityData, parentEntity: IEntityData, userId: string, setValue: UseFormSetValue<IEntityData>, initFormState: (configName: string, defaultValues: IEntityData, fields: Record<string, IFieldConfig>, areAllFieldsReadonly?: boolean) => IRuntimeFormState) => {
+    formState: IRuntimeFormState;
+    initEntityData: IEntityData;
+};
+declare const InitOnEditFormState: (configName: string, fields: Record<string, IFieldConfig>, defaultValues: IEntityData, areAllFieldsReadonly: boolean, initFormState: (configName: string, defaultValues: IEntityData, fields: Record<string, IFieldConfig>, areAllFieldsReadonly?: boolean) => IRuntimeFormState) => {
+    formState: IRuntimeFormState;
+    initEntityData: IEntityData;
+};
+declare const ShowField: (filterText?: string, value?: SubEntityType, label?: string) => boolean;
+declare const GetFieldsToRender: (fieldRenderLimit: number, fieldOrder: string[], fieldStates?: Record<string, IRuntimeFieldState>) => IFieldToRender[];
+/** Sort options alphabetically by label */
+declare const SortOptions$1: (options: IOption[]) => IOption[];
+
+/** Sort options alphabetically by label */
+declare function SortOptions(options: IOption[]): IOption[];
+
+interface ICycleError {
+    type: "dependency" | "self";
+    fields: string[];
+    message: string;
+}
+/**
+ * Detects circular dependencies in field rules using Kahn's algorithm.
+ * Operates on the dependency graph built from IFieldConfig.rules.
+ */
+declare function detectDependencyCycles(fields: Record<string, IFieldConfig>): ICycleError[];
+/**
+ * Detects self-dependencies (a field's rule references itself in a way that causes loops).
+ */
+declare function detectSelfDependencies(fields: Record<string, IFieldConfig>): ICycleError[];
+/**
+ * Validates the full dependency graph of field configs.
+ * Logs warnings in development, returns errors for programmatic use.
+ */
+declare function validateDependencyGraph(fields: Record<string, IFieldConfig>): ICycleError[];
+
+/**
+ * Unified validator function signature.
+ * Handles sync, async, and cross-field validation.
+ *
+ * @param value - The field's current value
+ * @param params - Parameters from IValidationRule.params
+ * @param context - Full form context (values, field name, abort signal)
+ * @returns Error message string, undefined if valid, or a Promise for async
+ */
+type ValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: IValidationContext) => string | undefined | Promise<string | undefined>;
+interface IValidationContext {
+    fieldName: string;
+    values: IEntityData;
+    signal?: AbortSignal;
+}
+/** Register custom validators (merge into registry) */
+declare function registerValidators(custom: Record<string, ValidatorFn>): void;
+/** Get a validator by name */
+declare function getValidator(name: string): ValidatorFn | undefined;
+/** Get a copy of the full registry */
+declare function getValidatorRegistry(): Record<string, ValidatorFn>;
+/** Reset registry to defaults (for testing) */
+declare function resetValidatorRegistry(): void;
+/**
+ * Run all validation rules for a field value.
+ * Handles sync, async, and conditional validation.
+ */
+declare function runValidations(value: unknown, rules: IValidationRule[], context: IValidationContext): Promise<string | undefined>;
+/**
+ * Run only sync validation rules (no await, fast fail).
+ */
+declare function runSyncValidations(value: unknown, rules: IValidationRule[], context: IValidationContext): string | undefined;
+declare function createMinLengthRule(min: number, message?: string): IValidationRule;
+declare function createMaxLengthRule(max: number, message?: string): IValidationRule;
+declare function createNumericRangeRule(min: number, max: number, message?: string): IValidationRule;
+declare function createPatternRule(pattern: string, message: string): IValidationRule;
+declare function createRequiredIfRule(field: string, values: string[], message?: string): IValidationRule;
+
+/**
+ * Value function signature (v2).
+ * Used in computed value expressions via $fn.name() syntax.
+ */
+type ValueFunction = (context: IValueFunctionContext) => SubEntityType;
+interface IValueFunctionContext {
+    fieldName: string;
+    fieldValue?: SubEntityType;
+    values: IEntityData;
+    parentEntity?: IEntityData;
+    currentUserId?: string;
+}
+/** Register custom value functions (merge into registry) */
+declare function registerValueFunctions(custom: Record<string, ValueFunction>): void;
+/** Get a value function by name */
+declare function getValueFunction(name: string): ValueFunction | undefined;
+/** Execute a named value function */
+declare function executeValueFunction(fieldName: string, functionName: string, values: IEntityData, fieldValue?: SubEntityType, parentEntity?: IEntityData, currentUserId?: string): SubEntityType;
+/** Reset registry to defaults (for testing) */
+declare function resetValueFunctionRegistry(): void;
+
+interface IConfigValidationError {
+    type: "missing_rule_target" | "unregistered_component" | "unregistered_validator" | "circular_dependency" | "self_dependency" | "missing_options" | "invalid_condition";
+    fieldName: string;
+    message: string;
+    details?: string;
+}
+/**
+ * Validates field configs for common issues at dev time.
+ *
+ * Checks:
+ * - Rule conditions reference existing fields
+ * - Cross-field effects target existing fields
+ * - Component types are registered (if registry provided)
+ * - Validators are registered
+ * - Dropdown fields have options or rules providing them
+ * - No circular/self dependencies
+ */
+declare function validateFieldConfigs(fields: Record<string, IFieldConfig>, registeredComponents?: Set<string>): IConfigValidationError[];
+
+/**
+ * Register a partial or full locale override. Unspecified keys fall back to English defaults.
+ * Can be called multiple times; each call merges into the current locale.
+ */
+declare function registerLocale(partial: Partial<ICoreLocaleStrings>): void;
+/**
+ * Get a locale string by key. Returns the registered locale value or the English default.
+ */
+declare function getLocaleString<K extends keyof ICoreLocaleStrings>(key: K): ICoreLocaleStrings[K];
+/**
+ * Reset the locale to English defaults. Useful for testing.
+ */
+declare function resetLocale(): void;
+/**
+ * Get the full current locale object. Useful for debugging or bulk operations.
+ */
+declare function getCurrentLocale(): ICoreLocaleStrings;
+
+interface IWizardNavigationProps {
+    steps: IWizardStep[];
+    currentStepIndex: number;
+    goToStep: (index: number) => void;
+    canGoNext: boolean;
+    canGoPrev: boolean;
+    goNext: () => void;
+    goPrev: () => void;
+}
+interface IWizardStepHeaderProps {
+    step: IWizardStep;
+    stepIndex: number;
+    totalSteps: number;
+}
+interface IWizardFormProps {
+    wizardConfig: IWizardConfig;
+    entityData: IEntityData;
+    fieldStates?: Record<string, IRuntimeFieldState>;
+    errors?: Record<string, unknown>;
+    renderStepContent: (fields: string[]) => React.ReactNode;
+    renderStepNavigation?: (props: IWizardNavigationProps) => React.ReactNode;
+    renderStepHeader?: (props: IWizardStepHeaderProps) => React.ReactNode;
+    onStepChange?: (fromIndex: number, toIndex: number) => void;
+    /** Analytics callback for wizard step changes. */
+    onAnalyticsStepChange?: (fromStep: number, toStep: number) => void;
+}
+declare const WizardForm: React.FC<IWizardFormProps>;
+
+declare function getVisibleSteps(steps: IWizardStep[], entityData: IEntityData): IWizardStep[];
+declare function getStepFields(step: IWizardStep, fieldStates?: Record<string, IRuntimeFieldState>): string[];
+declare function getStepFieldOrder(steps: IWizardStep[], entityData: IEntityData): string[];
+declare function validateStepFields(step: IWizardStep, errors: Record<string, unknown>): string[];
+declare function isStepValid(step: IWizardStep, errors: Record<string, unknown>): boolean;
+declare function getStepIndex(steps: IWizardStep[], stepId: string): number;
+
+interface IFieldArrayProps {
+    fieldName: string;
+    config: IFieldConfig;
+    renderItem: (itemFieldNames: string[], index: number, remove: () => void) => React.ReactNode;
+    renderAddButton?: (append: () => void, canAdd: boolean) => React.ReactNode;
+}
+declare const FieldArray: React.FC<IFieldArrayProps>;
+
+interface IFormEngineProps extends IFormEngineSharedProps {
+    /** v2 form config (preferred). If provided, fieldConfigs is ignored. */
+    formConfig?: IFormConfig;
+    /** v1-style field configs (for migration). Use formConfig instead. */
+    fieldConfigs?: Record<string, IFieldConfig>;
+    defaultValues: IEntityData;
+    isChildEntity?: boolean;
+    saveData?: (entityData: IEntityData, dirtyFieldNames?: string[]) => Promise<IEntityData>;
+    saveTimeoutMs?: number;
+    maxSaveRetries?: number;
+    renderExpandButton?: (props: {
+        isExpanded: boolean;
+        onToggle: () => void;
+    }) => React.JSX.Element;
+    renderFilterInput?: (props: {
+        onChange: (value: string) => void;
+    }) => React.JSX.Element;
+    renderDialog?: (props: {
+        isOpen: boolean;
+        onSave: () => void;
+        onCancel: () => void;
+        children: React.ReactNode;
+    }) => React.JSX.Element;
+    isManualSave?: boolean;
+    renderSaveButton?: (props: {
+        onSave: () => void;
+        isDirty: boolean;
+        isValid: boolean;
+        isSubmitting: boolean;
+    }) => React.ReactNode;
+    formErrors?: string[];
+    renderLabel?: (props: {
+        id: string;
+        labelId: string;
+        label?: string;
+        required?: boolean;
+    }) => React.ReactNode;
+    renderError?: (props: {
+        id: string;
+        error?: react_hook_form.FieldError;
+        errorCount?: number;
+    }) => React.ReactNode;
+    renderStatus?: (props: {
+        id: string;
+        saving?: boolean;
+        savePending?: boolean;
+        errorCount?: number;
+        isManualSave?: boolean;
+    }) => React.ReactNode;
+}
+declare const FormEngine: React.FC<IFormEngineProps>;
+
+/**
+ * Stable wrapper functions for analytics callbacks.
+ * Each function is a no-op when the corresponding callback is not provided.
+ */
+interface IFormAnalytics {
+    trackFieldFocus: (fieldName: string) => void;
+    trackFieldBlur: (fieldName: string) => void;
+    trackFieldChange: (fieldName: string, oldValue: unknown, newValue: unknown) => void;
+    trackValidationError: (fieldName: string, errors: string[]) => void;
+    trackFormSubmit: (values: Record<string, unknown>) => void;
+    trackFormAbandonment: (filledFields: string[], emptyRequiredFields: string[]) => void;
+    trackWizardStepChange: (fromStep: number, toStep: number) => void;
+    trackRuleTriggered: (event: {
+        fieldName: string;
+        ruleIndex: number;
+        conditionMet: boolean;
+    }) => void;
+    /** Timestamp (ms) when the hook was first created -- used for form duration. */
+    formStartTime: number;
+}
+/**
+ * Hook that wraps IAnalyticsCallbacks into safe, memoized wrapper functions.
+ * Tracks form start time for duration calculations and per-field focus times.
+ */
+declare function useFormAnalytics(callbacks?: IAnalyticsCallbacks): IFormAnalytics;
+
+interface IFormFieldsProps {
+    entityId?: string;
+    entityType?: string;
+    programName?: string;
+    parentEntityId?: string;
+    parentEntityType?: string;
+    isExpanded?: boolean;
+    expandEnabled?: boolean;
+    fieldOrder?: string[];
+    inPanel?: boolean;
+    collapsedMaxHeight?: number;
+    formState?: IRuntimeFormState;
+    fields?: Record<string, IFieldConfig>;
+    setFieldValue: (fieldName: string, fieldValue: unknown, skipSave?: boolean) => void;
+    isManualSave?: boolean;
+    isCreate?: boolean;
+    filterText?: string;
+    fieldRenderLimit?: number;
+    renderLabel?: (props: {
+        id: string;
+        labelId: string;
+        label?: string;
+        required?: boolean;
+    }) => React.ReactNode;
+    renderError?: (props: {
+        id: string;
+        error?: react_hook_form.FieldError;
+        errorCount?: number;
+    }) => React.ReactNode;
+    renderStatus?: (props: {
+        id: string;
+        saving?: boolean;
+        savePending?: boolean;
+        errorCount?: number;
+        isManualSave?: boolean;
+    }) => React.ReactNode;
+    analytics?: IFormAnalytics;
+}
+declare const FormFields: (props: IFormFieldsProps) => react_jsx_runtime.JSX.Element;
+
+interface IFieldWrapperProps {
+    id?: string;
+    readonly label?: string;
+    readonly required?: boolean;
+    readonly error?: FieldError;
+    readonly errorCount?: number;
+    readonly savePending?: boolean;
+    readonly saving?: boolean;
+    readonly labelClassName?: string;
+    readonly fieldClassName?: string;
+    readonly showControlonSide?: boolean;
+    readonly ariaLabel?: string;
+    readonly ariaDescription?: string;
+    readonly containerClassName?: string;
+    readonly additionalInfo?: string;
+    readonly additionalInfoIcon?: string;
+    readonly additionalInfoComponent?: React.ReactNode;
+    isManualSave?: boolean;
+    renderLabel?: (props: {
+        id: string;
+        labelId: string;
+        label?: string;
+        required?: boolean;
+    }) => React.ReactNode;
+    renderError?: (props: {
+        id: string;
+        error?: FieldError;
+        errorCount?: number;
+    }) => React.ReactNode;
+    renderStatus?: (props: {
+        id: string;
+        saving?: boolean;
+        savePending?: boolean;
+        errorCount?: number;
+        isManualSave?: boolean;
+    }) => React.ReactNode;
+}
+declare const FieldWrapper: React.FunctionComponent<React.PropsWithChildren<IFieldWrapperProps>>;
+
+interface IRenderFieldProps {
+    fieldName: string;
+    entityId?: string;
+    entityType?: string;
+    programName?: string;
+    type: string;
+    hidden?: boolean;
+    required?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+    options?: IOption[];
+    validate?: IValidationRule[];
+    parentEntityId?: string;
+    parentEntityType?: string;
+    isManualSave?: boolean;
+    setFieldValue: (fieldName: string, fieldValue: unknown, skipSave?: boolean) => void;
+    isCreate?: boolean;
+    filterText?: string;
+    softHidden?: boolean;
+    label?: string;
+    skipLayoutReadOnly?: boolean;
+    hideOnCreate?: boolean;
+    config?: Record<string, unknown>;
+    description?: string;
+    placeholder?: string;
+    helpText?: string;
+    renderLabel?: (props: {
+        id: string;
+        labelId: string;
+        label?: string;
+        required?: boolean;
+    }) => React.ReactNode;
+    renderError?: (props: {
+        id: string;
+        error?: react_hook_form.FieldError;
+        errorCount?: number;
+    }) => React.ReactNode;
+    renderStatus?: (props: {
+        id: string;
+        saving?: boolean;
+        savePending?: boolean;
+        errorCount?: number;
+        isManualSave?: boolean;
+    }) => React.ReactNode;
+    analytics?: IFormAnalytics;
+}
+declare const _default: React.MemoExoticComponent<(props: IRenderFieldProps) => react_jsx_runtime.JSX.Element>;
+
+interface IConfirmInputsModalProps {
+    isOpen?: boolean;
+    configName: string;
+    entityId?: string;
+    entityType?: string;
+    programName?: string;
+    fields: Record<string, IFieldConfig>;
+    confirmInputFields: string[];
+    saveConfirmInputFields: () => void;
+    cancelConfirmInputFields: () => void;
+    renderDialog?: (props: {
+        isOpen: boolean;
+        onSave: () => void;
+        onCancel: () => void;
+        children: React.ReactNode;
+    }) => React.JSX.Element;
+}
+declare const ConfirmInputsModal: (props: IConfirmInputsModalProps) => React.JSX.Element;
+
+interface IFormErrorBoundaryProps {
+    children: React.ReactNode;
+    fallback?: (error: Error, resetError: () => void) => React.ReactNode;
+    onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
+}
+interface IFormErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class FormErrorBoundary extends React.Component<IFormErrorBoundaryProps, IFormErrorBoundaryState> {
+    constructor(props: IFormErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): IFormErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    resetError: () => void;
+    render(): React.ReactNode;
+}
+
+interface IFormDevToolsProps {
+    configName: string;
+    formState?: IRuntimeFormState;
+    formValues?: Record<string, unknown>;
+    formErrors?: Record<string, unknown>;
+    dirtyFields?: Record<string, boolean>;
+    enabled?: boolean;
+}
+declare const FormDevTools: React.FC<IFormDevToolsProps>;
+
+/**
+ * JSON Schema node type (supports draft-04 through draft-2020-12 features used by RJSF).
+ */
+interface IJsonSchemaNode {
+    $ref?: string;
+    definitions?: Record<string, IJsonSchemaNode>;
+    $defs?: Record<string, IJsonSchemaNode>;
+    type?: string | string[];
+    const?: unknown;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    enum?: unknown[];
+    enumNames?: string[];
+    properties?: Record<string, IJsonSchemaNode>;
+    required?: string[];
+    additionalProperties?: boolean | IJsonSchemaNode;
+    items?: IJsonSchemaNode | IJsonSchemaNode[];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    oneOf?: IJsonSchemaNode[];
+    anyOf?: IJsonSchemaNode[];
+    allOf?: IJsonSchemaNode[];
+    if?: IJsonSchemaNode;
+    then?: IJsonSchemaNode;
+    else?: IJsonSchemaNode;
+    dependencies?: Record<string, string[] | IJsonSchemaNode>;
+    [key: string]: unknown;
+}
+/**
+ * RJSF uiSchema type — controls rendering hints separate from the data schema.
+ */
+interface IRjsfUiSchema {
+    "ui:widget"?: string;
+    "ui:field"?: string;
+    "ui:options"?: Record<string, unknown>;
+    "ui:order"?: string[];
+    "ui:hidden"?: boolean;
+    "ui:readonly"?: boolean;
+    "ui:disabled"?: boolean;
+    "ui:placeholder"?: string;
+    "ui:title"?: string;
+    "ui:description"?: string;
+    "ui:help"?: string;
+    "ui:autofocus"?: boolean;
+    "ui:enumDisabled"?: unknown[];
+    "ui:enumNames"?: string[];
+    "ui:label"?: boolean;
+    "ui:classNames"?: string;
+    "ui:submitButtonOptions"?: Record<string, unknown>;
+    [fieldName: string]: unknown;
+}
+/**
+ * Options for controlling the RJSF-to-IFormConfig conversion.
+ */
+interface IRjsfConvertOptions {
+    /** "flatten" = dot-notation keys (default), "fieldArray" = FieldArray items */
+    nestedObjectStrategy?: "flatten" | "fieldArray";
+    /** Prefix for generated rule IDs (default: "rjsf") */
+    ruleIdPrefix?: string;
+}
+
+/**
+ * Convert an RJSF schema + uiSchema + formData into an IFormConfig (v2).
+ *
+ * This is the main entry point for RJSF migration. It:
+ * 1. Resolves all $ref pointers
+ * 2. Merges allOf if present
+ * 3. Maps properties to IFieldConfig
+ * 4. Applies uiSchema rendering hints
+ * 5. Merges formData as defaultValues
+ * 6. Converts dependencies → IRule[]
+ * 7. Converts if/then/else → IRule[]
+ * 8. Converts oneOf/anyOf → IRule[]
+ * 9. Determines fieldOrder from uiSchema or property order
+ */
+declare function fromRjsfSchema(schema: IJsonSchemaNode, uiSchema?: IRjsfUiSchema, formData?: Record<string, unknown>, options?: IRjsfConvertOptions): IFormConfig;
+
+/**
+ * Reverse-convert an IFormConfig to JSON Schema + uiSchema.
+ *
+ * Best-effort: structural fidelity only. Rules, computed values,
+ * and other dynamic features do NOT map back to JSON Schema.
+ */
+declare function toRjsfSchema(config: IFormConfig): {
+    schema: IJsonSchemaNode;
+    uiSchema: IRjsfUiSchema;
+};
+
+/**
+ * Converts a Zod object schema to Record<string, IFieldConfig>.
+ * Does NOT require zod as a dependency — inspects the schema shape at runtime.
+ */
+declare function zodSchemaToFieldConfig(zodSchema: unknown): Record<string, IFieldConfig>;
+
+type LazyFieldImport = () => Promise<{
+    default: React.ComponentType<any>;
+}>;
+/**
+ * Creates a field registry where components are loaded on-demand via React.lazy().
+ * Fields are only loaded when first rendered, reducing initial bundle size.
+ *
+ * @example
+ * const registry = createLazyFieldRegistry({
+ *   Textbox: () => import("./fields/Textbox"),
+ *   Dropdown: () => import("./fields/Dropdown"),
+ * });
+ */
+declare function createLazyFieldRegistry(imports: Record<string, LazyFieldImport>): Dictionary<React.JSX.Element>;
+
+interface IDraftPersistenceOptions {
+    /** Unique form identifier for storage key */
+    formId: string;
+    /** Current form data to persist */
+    data: IEntityData;
+    /** Auto-save interval in ms (default 30000) */
+    saveIntervalMs?: number;
+    /** Whether persistence is enabled (default true) */
+    enabled?: boolean;
+    /** Custom storage key prefix (default "draft_") */
+    storageKeyPrefix?: string;
+}
+interface IDraftState {
+    data: IEntityData;
+    timestamp: number;
+}
+interface IUseDraftPersistenceResult {
+    /** Recover a saved draft if one exists */
+    recoverDraft: () => IDraftState | null;
+    /** Clear the saved draft */
+    clearDraft: () => void;
+    /** Whether a draft exists */
+    hasDraft: boolean;
+    /** Manually save current state as draft */
+    saveDraft: () => void;
+}
+/**
+ * Hook that persists form draft state to localStorage on a configurable interval.
+ *
+ * Handles localStorage errors gracefully (e.g. private browsing, quota exceeded).
+ */
+declare function useDraftPersistence(options: IDraftPersistenceOptions): IUseDraftPersistenceResult;
+
+/**
+ * Hook that warns the user before navigating away when there are unsaved changes.
+ *
+ * @param shouldWarn - Whether the beforeunload warning should be active
+ * @param message - Custom message (modern browsers ignore custom text but still show a prompt)
+ * @param onAbandonment - Optional analytics callback fired when the user leaves with unsaved changes
+ */
+declare function useBeforeUnload(shouldWarn: boolean, message?: string, onAbandonment?: () => void): void;
+
+/**
+ * Serialize form state to a JSON string, preserving Date objects
+ * with a special `__type` marker so they can be round-tripped.
+ */
+declare function serializeFormState(data: IEntityData): string;
+/**
+ * Deserialize a JSON string back to form state, restoring Date objects
+ * that were serialized with `serializeFormState`.
+ */
+declare function deserializeFormState(json: string): IEntityData;
+
+/**
+ * Evaluates an expression string against form values.
+ *
+ * Supports:
+ * - $values.fieldName for field references (including nested paths)
+ * - $fn.name() for value function calls
+ * - $parent.fieldName for parent entity references
+ * - $root.fieldName alias for $values.fieldName
+ * - Math functions: Math.round, Math.floor, Math.ceil, Math.abs, Math.min, Math.max
+ * - Arithmetic: +, -, *, /
+ * - Comparison: >, <, >=, <=, ===, !==
+ * - Logical: &&, ||
+ * - String concatenation via +
+ *
+ * @example
+ *   "$values.quantity * $values.unitPrice"
+ *   "$fn.setDate()"
+ *   "$parent.category"
+ *   "Math.round($values.total * 100) / 100"
+ */
+declare function evaluateExpression(expression: string, values: IEntityData, fieldName?: string, parentEntity?: IEntityData, currentUserId?: string): unknown;
+/**
+ * Extracts field names referenced in an expression via $values.fieldName or $root.fieldName.
+ */
+declare function extractExpressionDependencies(expression: string): string[];
+/**
+ * Extracts value function names referenced via $fn.name() syntax.
+ */
+declare function extractFunctionDependencies(expression: string): string[];
+
+interface IRuleTraceEvent {
+    timestamp: number;
+    type: "evaluate" | "apply" | "revert" | "init";
+    triggerField: string;
+    triggerValue: unknown;
+    affectedField: string;
+    ruleId?: string;
+    previousState?: Partial<IRuntimeFieldState>;
+    newState?: Partial<IRuntimeFieldState>;
+}
+declare function enableRuleTracing(callback?: (event: IRuleTraceEvent) => void): void;
+declare function disableRuleTracing(): void;
+declare function traceRuleEvent(event: Omit<IRuleTraceEvent, "timestamp">): void;
+declare function getRuleTraceLog(): IRuleTraceEvent[];
+declare function clearRuleTraceLog(): void;
+declare function isRuleTracingEnabled(): boolean;
+
+/**
+ * RenderTracker — Module-level render count tracking for FormDevTools.
+ *
+ * Tracks per-field render counts and which fields re-rendered on the last change.
+ */
+/**
+ * Record a render for the given field. Call this from RenderField.
+ */
+declare function trackRender(fieldName: string): void;
+/**
+ * Call once per form render cycle to snapshot which fields rendered.
+ */
+declare function flushRenderCycle(): void;
+/**
+ * Returns the current render counts for all tracked fields.
+ */
+declare function getRenderCounts(): Map<string, number>;
+/**
+ * Returns the set of field names that rendered in the last cycle.
+ */
+declare function getLastRenderedFields(): Set<string>;
+/**
+ * Returns total form render count.
+ */
+declare function getTotalFormRenders(): number;
+/**
+ * Reset all tracking data.
+ */
+declare function resetRenderTracker(): void;
+
+/**
+ * EventTimeline — Module-level chronological event log for FormDevTools.
+ *
+ * Logs timestamped events from the rules engine, field changes, and validations.
+ */
+type TimelineEventType = "field_change" | "rule_evaluated" | "validation_run" | "form_submit";
+interface ITimelineEvent {
+    timestamp: number;
+    type: TimelineEventType;
+    fieldName: string;
+    details: string;
+}
+/**
+ * Log a new event to the timeline.
+ */
+declare function logEvent(type: TimelineEventType, fieldName: string, details: string): void;
+/**
+ * Returns a copy of the full timeline.
+ */
+declare function getTimeline(): ITimelineEvent[];
+/**
+ * Clear all timeline events.
+ */
+declare function clearTimeline(): void;
+
+export { CheckAsyncFieldValidationRules, CheckDefaultValues, CheckFieldValidationRules, CheckValidDropdownOptions, ComponentTypes, ConfirmInputsModal, type Dictionary, ExecuteComputedValue, FIELD_PARENT_PREFIX, FieldArray, FieldWrapper, FormConstants, FormDevTools, FormEngine, FormErrorBoundary, FormFields, FormStrings, GetChildEntity, GetComputedValuesOnCreate, GetComputedValuesOnDirtyFields, GetConfirmInputModalProps, GetFieldsToRender, type IAnalyticsCallbacks, type IClearRulesAction, type ICondition, type IConfigValidationError, type IConfirmInputModalProps, type ICoreLocaleStrings, type ICycleError, type IDraftPersistenceOptions, type IDraftState, type IEntityData, type IFieldArrayProps, type IFieldCondition, type IFieldConfig, type IFieldEffect, type IFieldProps, type IFieldToRender, type IFormAnalytics, type IFormConfig, type IFormDevToolsProps, type IFormEngineSharedProps, type IFormSettings, type IInjectedFieldProvider, type IJsonSchemaNode, type ILogicalCondition, type IOption, type IRjsfConvertOptions, type IRjsfUiSchema, type IRule, type IRuleTraceEvent, type IRulesEngineProvider, type IRulesEngineState, type IRuntimeFieldState, type IRuntimeFormState, type ISetRulesAction, type ITimelineEvent, type IUpdateRulesAction, type IUseDraftPersistenceResult, type IValidationContext, type IValidationRule, type IValueFunctionContext, type IWizardConfig, type IWizardFormProps, type IWizardNavigationProps, type IWizardStep, type IWizardStepHeaderProps, InitOnCreateFormState, InitOnEditFormState, InjectedFieldProvider, IsExpandVisible, _default as RenderField, type RulesEngineAction, RulesEngineActionType, RulesEngineProvider, ShowField, SortOptions as SortDropdownOptions, SortOptions$1 as SortOptions, type SubEntityType, type TimelineEventType, type TypedFieldConfig, UseInjectedFieldContext, UseRulesEngineContext, type ValidatorFn, type ValueFunction, WizardForm, buildDefaultFieldStates, buildDependencyGraph, clearRuleTraceLog, clearTimeline, convertBooleanToYesOrNoText, createLazyFieldRegistry, createMaxLengthRule, createMinLengthRule, createNumericRangeRule, createOption, createPatternRule, createRequiredIfRule, deepCopy, defineFormConfig, deserializeFormState, detectDependencyCycles, detectSelfDependencies, disableRuleTracing, enableRuleTracing, evaluateAffectedFields, evaluateAllRules, evaluateCondition, evaluateExpression, executeValueFunction, extractConditionDependencies, extractExpressionDependencies, extractFunctionDependencies, flushRenderCycle, fromRjsfSchema, getCurrentLocale, getLastRenderedFields, getLocaleString, getRenderCounts, getRuleTraceLog, getStepFieldOrder, getStepFields, getStepIndex, getTimeline, getTotalFormRenders, getValidator, getValidatorRegistry, getValueFunction, getVisibleSteps, isEmpty, isFieldCondition, isLogicalCondition, isNull, isRuleTracingEnabled, isStepValid, isStringEmpty, logEvent, registerLocale, registerValidators, registerValueFunctions, resetLocale, resetRenderTracker, resetValidatorRegistry, resetValueFunctionRegistry, runSyncValidations, runValidations, serializeFormState, sortDropdownOptions, toRjsfSchema, topologicalSort, traceRuleEvent, trackRender, useBeforeUnload, useDraftPersistence, useFormAnalytics, validateDependencyGraph, validateFieldConfigs, validateStepFields, zodSchemaToFieldConfig };