@syncfusion/ej2-react-form-renderer 0.1.1-beta → 0.1.2-beta

package/src/FormRenderer.js

@@ -6,15 +6,17 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React, { useState, useEffect, useRef, useCallback } from 'react';
 import { Form, FormField } from './FormValidator';
 import { enableRipple } from '@syncfusion/ej2-base';
-import { renderFormField } from './renderFormField';
+import { RenderFormField } from './renderFormField';
 import { CustomTabComponent } from './CustomTabComponent';
-import { mergeSchema, convertComponentsToDataSchema, generateUIPropertiesFromData, generateLayoutFromData, generateDataSchemaFromUI } from './json-converter';
+import { mergeSchema } from './json-converter';
 import { UniversalJsonParser } from './parser';
 import { TooltipComponent } from '@syncfusion/ej2-react-popups';
 import { VALIDATION_REGEX } from './FormValidator';
 import StaticHtmlRenderer from './StaticHtmlRenderer';
 import { formatDateValues, splitWidths } from './utils';
 import { ConditionalRuleEngine } from './ConditionalRuleEngine';
+import { ExpressionEngine } from './expressions/ExpressionEngine';
+import { MinMaxRuleEngine } from './MinMaxRuleEngine';
 enableRipple(true);
 /**
  * Form layout options (only applies when UI schema is NOT provided)
@@ -25,147 +27,45 @@ export const FormLayout = {
     ThreeColumn: 'threecolumn',
     FourColumn: 'fourcolumn'
 };
-/**
- * Helper: Normalize DataSchema input
- * Converts any object to JSON string and parses with UniversalJsonParser
- * Handles FormSchema, DataSchema, or raw data - parser infers the format
- */
-function normalizeDataSchema(input) {
-    try {
-        // Convert object to JSON string
-        const jsonString = JSON.stringify(input);
-        const parser = new UniversalJsonParser();
-        const parseResult = parser.parse(jsonString);
-        if (parseResult.success && parseResult.schema) {
-            const dataSchema = convertComponentsToDataSchema(parseResult.schema.components);
-            // console.log(`✅ Parsed object as ${parseResult.metadata.detectedFormat} and converted to DataSchema`);
-            return dataSchema;
-        }
-        else {
-            console.error('❌ Failed to parse object:', parseResult.errors);
-            return null;
-        }
-    }
-    catch (error) {
-        console.error('❌ DataSchema normalization error:', error);
-        return null;
-    }
-}
-/**
- * Helper: Parse string input using UniversalJsonParser
- * Returns DataSchema if parseable, otherwise null
- * Validates that UI schema was not accidentally provided
- */
-function parseStringToDataSchema(input) {
-    try {
-        // First check if user accidentally pasted UI schema in data schema field
-        const testParse = JSON.parse(input);
-        if (testParse.layout || (testParse.theme && testParse.properties && testParse.layout)) {
-            console.error('The provided schema is a UI Schema in the data schema prop. Please provide a valid Data Schema with field definitions and validation rules.');
-            return null;
-        }
-        const parser = new UniversalJsonParser();
-        const parseResult = parser.parse(input);
-        if (parseResult.success && parseResult.schema) {
-            const dataSchema = convertComponentsToDataSchema(parseResult.schema.components);
-            return dataSchema;
-        }
-        else {
-            console.error('Failed to parse input:', parseResult.errors);
-            return null;
-        }
-    }
-    catch (error) {
-        console.error('Parser error:', error);
-        return null;
-    }
-}
-/**
- * Helper: Parse string input as UISchema
- * Validates JSON structure matches UISchema format
- * Detects if data schema was accidentally provided
- */
-function parseStringToUISchema(input) {
-    try {
-        const parsed = JSON.parse(input);
-        // Check if data schema was pasted in UI schema field
-        if (parsed.properties && !parsed.layout && !parsed.theme) {
-            const hasValidationProps = Object.values(parsed.properties).some((prop) => prop.required !== undefined || prop.minLength !== undefined || prop.maxLength !== undefined ||
-                prop.minValue !== undefined || prop.maxValue !== undefined || prop.pattern !== undefined);
-            if (hasValidationProps) {
-                console.error('The provided schema is a Data Schema in the UI schema prop. Please provide a valid UI Schema with theme, properties, and layout definitions.');
-                return null;
-            }
-        }
-        // Validate UISchema structure
-        if (!parsed.theme || !parsed.properties || !parsed.layout) {
-            console.error('Invalid UISchema: missing theme, properties, or layout');
-            return null;
-        }
-        return parsed;
-    }
-    catch (error) {
-        console.error('JSON parse error:', error);
-        return null;
-    }
-}
 // ForwardRef to expose public methods
-export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, onSubmit, onChange, onButtonClick, className = '', layout = FormLayout.SingleColumn, created, ...restProps }, ref) => {
+export const FormRenderer = React.forwardRef(({ schema, locale, onSubmit, onChange, onButtonClick, className = '', layout = FormLayout.SingleColumn, created, ...restProps }, ref) => {
     const processedSchema = React.useMemo(() => {
         try {
-            // Parse and normalize data schema
-            let parsedDataSchema = dataSchema
-                ? ((typeof dataSchema === 'string'
-                    ? parseStringToDataSchema(dataSchema)
-                    : normalizeDataSchema(dataSchema)) || undefined)
-                : undefined;
-            // Parse and normalize UI schema
-            let parsedUISchema = uiSchema
-                ? (typeof uiSchema === 'string'
-                    ? parseStringToUISchema(uiSchema)
-                    : uiSchema) || undefined
-                : undefined;
-            // Scenario 1: Both dataSchema and uiSchema provided - full merge
-            if (parsedDataSchema && parsedUISchema) {
-                const uiFieldIds = new Set(Object.keys(parsedUISchema.properties));
-                const dataFieldIds = Object.keys(parsedDataSchema.properties);
-                const missingFields = dataFieldIds.filter(id => !uiFieldIds.has(id));
-                if (missingFields.length > 0) {
-                    console.warn(`⚠️ Found ${missingFields.length} fields in data schema missing from UI schema`);
+            if (!schema) {
+                return { version: '1.0.0', components: [] };
+            }
+            let parsedInput = schema;
+            if (typeof schema === 'string') {
+                try {
+                    parsedInput = JSON.parse(schema);
+                }
+                catch (err) {
+                    console.error('FormRenderer: Failed to parse schema string', err);
+                    return { version: '1.0.0', components: [] };
                 }
-                const merged = mergeSchema({ dataSchema: parsedDataSchema, uiSchema: parsedUISchema });
-                return merged;
             }
-            // Scenario 2: Only dataSchema provided - auto-generate UI schema
-            if (parsedDataSchema && !parsedUISchema) {
-                const autoUISchema = {
-                    properties: generateUIPropertiesFromData(parsedDataSchema),
-                    layout: generateLayoutFromData(parsedDataSchema)
-                };
-                const merged = mergeSchema({ dataSchema: parsedDataSchema, uiSchema: autoUISchema });
-                return merged;
+            const isUnifiedSchema = parsedInput && typeof parsedInput === 'object' &&
+                parsedInput.properties && Array.isArray(parsedInput.layout);
+            if (isUnifiedSchema) {
+                return mergeSchema(parsedInput);
             }
-            // Scenario 3: Only uiSchema provided - auto-generate data schema
-            if (!parsedDataSchema && parsedUISchema) {
-                const autoDataSchema = generateDataSchemaFromUI(parsedUISchema);
-                const uiFieldIds = new Set(Object.keys(parsedUISchema.properties));
-                const dataFieldIds = Object.keys(autoDataSchema.properties);
-                const missingFields = dataFieldIds.filter(id => !uiFieldIds.has(id));
-                if (missingFields.length > 0) {
-                    console.warn(`Found ${missingFields.length} fields in auto-generated data schema missing from UI schema`);
+            else {
+                const parser = new UniversalJsonParser();
+                const parseResult = parser.parse(typeof schema === 'string' ? schema : JSON.stringify(schema));
+                if (parseResult.success && parseResult.schema) {
+                    return parseResult.schema;
+                }
+                else {
+                    console.warn('FormRenderer: Failed to parse schema', parseResult.errors);
+                    return { version: '1.0.0', components: [] };
                 }
-                const merged = mergeSchema({ dataSchema: autoDataSchema, uiSchema: parsedUISchema });
-                return merged;
             }
-            // Scenario 4: Neither provided - return empty form
-            console.warn('FormRenderer: No schema provided (dataSchema or uiSchema)');
-            return { version: '0.1.0', theme: 'tailwind3', components: [] };
         }
         catch (error) {
             console.error('FormRenderer schema processing error:', error);
-            return { version: '0.1.0', theme: 'tailwind3', components: [] };
+            return { version: '1.0.0', components: [] };
         }
-    }, [dataSchema, uiSchema]);
+    }, [schema]);
     const [formState, setFormState] = useState(undefined);
     const isInitializedRef = useRef(false);
     const formLocale = locale || 'en-US';
@@ -175,6 +75,12 @@ export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, on
     const inputRefs = useRef({});
     // Track which fields have active conditional values applied (to prevent re-applying while condition stays true)
     const conditionalValueAppliedRef = useRef({});
+    // Expression Engine initialization
+    const expressionEngineRef = useRef(null);
+    const expressionDependencyGraphRef = useRef({});
+    const expressionEvaluationInProgressRef = useRef(false);
+    const previousFormValuesRef = useRef({});
+    const computedFieldNamesRef = useRef(new Set());
     // Check if UI schema has layout components (table, tabs, or panel)
     const hasLayoutComponents = React.useMemo(() => {
         if (!processedSchema.components)
@@ -351,7 +257,7 @@ export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, on
         const componentIds = new Set();
         allComponents.forEach(comp => {
             // Do NOT store dataGrid data inside the form state; grids manage their own internal data.
-            if (comp.type === 'dataGrid' || comp.type === 'richTextEditor') {
+            if (comp.type === 'dataGrid' || comp.type === 'richTextEditor' || comp.type === 'staticHtml') {
                 componentIds.add(comp.id);
                 return;
             }
@@ -375,7 +281,7 @@ export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, on
             });
         }
         return values;
-    }, [processedSchema, collectAllComponents, dataSchema, uiSchema]);
+    }, [processedSchema, collectAllComponents, schema]);
     // Update the useEffect that sets default values
     useEffect(() => {
         if (formState && !isInitializedRef.current) {
@@ -390,6 +296,167 @@ export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, on
             });
         }
     }, [formState, processedSchema, initialValues]);
+    /**
+     * Initialize Expression Engine and build dependency graph
+     * Runs when schema changes
+     */
+    useEffect(() => {
+        if (!processedSchema.components || processedSchema.components.length === 0) {
+            return;
+        }
+        try {
+            // Initialize expression engine if not already done
+            if (!expressionEngineRef.current) {
+                expressionEngineRef.current = new ExpressionEngine();
+            }
+            const engine = expressionEngineRef.current;
+            const allComponents = collectAllComponents(processedSchema.components);
+            // Build dependency graph from all expressions
+            const graph = engine.buildDependencyGraph(allComponents);
+            // Check for circular dependencies
+            const cycles = engine.detectCircularDependencies(graph);
+            if (cycles.length > 0) {
+                //console.warn('⚠️ Circular dependencies detected in expressions:', cycles);
+            }
+            // Store dependency graph
+            expressionDependencyGraphRef.current = graph;
+            // Track which fields are computed by expressions
+            const computedFields = new Set();
+            allComponents.forEach(comp => {
+                if (comp.expressionValue) {
+                    computedFields.add(comp.id);
+                }
+            });
+            computedFieldNamesRef.current = computedFields;
+        }
+        catch (error) {
+            console.error('Error initializing expression engine:', error);
+        }
+    }, [processedSchema, collectAllComponents]);
+    /**
+     * Evaluate expressions when form values change
+     * Runs expressions in topological order to ensure dependencies are satisfied
+     */
+    useEffect(() => {
+        if (!formState || !expressionEngineRef.current) {
+            return;
+        }
+        // Prevent recursive evaluation loops
+        if (expressionEvaluationInProgressRef.current) {
+            return;
+        }
+        try {
+            expressionEvaluationInProgressRef.current = true;
+            const engine = expressionEngineRef.current;
+            const dependencyGraph = expressionDependencyGraphRef.current;
+            const formValues = formState.values || {};
+            const allComponents = collectAllComponents(processedSchema.components);
+            const previousValues = previousFormValuesRef.current;
+            const computedFieldNames = computedFieldNamesRef.current;
+            // Create a mapping of component id -> component name for context building
+            const idToNameMap = {};
+            allComponents.forEach(comp => {
+                if (comp.name) {
+                    idToNameMap[comp.id] = comp.name;
+                }
+            });
+            // Convert formValues from id-based keys to name-based keys for expression context
+            const contextValues = {};
+            Object.entries(formValues).forEach(([componentId, value]) => {
+                const fieldName = idToNameMap[componentId];
+                if (fieldName) {
+                    contextValues[fieldName] = value;
+                }
+            });
+            // Capture previous state before checking for changes
+            const previousContextValues = { ...previousValues };
+            // Update previous values immediately with current context for next cycle
+            // This ensures stale values don't affect the next evaluation cycle
+            Object.assign(previousValues, contextValues);
+            // Find which fields have changed (using captured previous state)
+            const changedFields = new Set();
+            Object.keys(contextValues).forEach(fieldName => {
+                const fieldId = Object.keys(idToNameMap).find(id => idToNameMap[id] === fieldName);
+                if (fieldId && contextValues[fieldName] !== previousContextValues[fieldName] && !computedFieldNames.has(fieldId)) {
+                    changedFields.add(fieldName);
+                }
+            });
+            // If no non-computed fields changed, skip evaluation
+            if (changedFields.size === 0) {
+                return;
+            }
+            // Get topological order for evaluation
+            const evaluationOrder = engine.getTopologicalOrder(dependencyGraph);
+            evaluationOrder.forEach(fieldName => {
+                // Find component with this name
+                const component = allComponents.find(c => c.name === fieldName);
+                if (component && component.expressionValue) {
+                    // Mark this field as computed
+                    computedFieldNames.add(component.id);
+                    try {
+                        // Only evaluate if field is visible and not read-only
+                        const isVisible = component.visible !== false
+                            ? ConditionalRuleEngine.isFieldVisible(component.conditions, formValues)
+                            : false;
+                        if (isVisible) {
+                            const currentValues = {};
+                            Object.entries(formValues).forEach(([componentId, value]) => {
+                                const fieldName = idToNameMap[componentId];
+                                if (fieldName) {
+                                    currentValues[fieldName] = value;
+                                }
+                            });
+                            // Use context values (name-based) for evaluation
+                            let result = engine.evaluate(component.expressionValue, currentValues);
+                            result = typeof (result) === 'string' && result.includes('undefined') ? result.replace(/undefined/g, '') : result;
+                            // Coerce result to appropriate type based on field type
+                            if (result !== null && result !== undefined && result !== '') {
+                                switch (component.type) {
+                                    case 'number':
+                                        // Ensure numeric fields return numbers (but preserve empty string)
+                                        const numResult = Number(result);
+                                        result = isNaN(numResult) ? 0 : numResult;
+                                        result = result === 0 ? "" : result;
+                                        break;
+                                    case 'checkbox':
+                                    case 'switch':
+                                        // Ensure boolean fields return booleans
+                                        result = Boolean(result);
+                                        break;
+                                    case 'textbox':
+                                    case 'textarea':
+                                        // Ensure text fields return strings
+                                        result = String(result);
+                                        break;
+                                    case 'dateRange':
+                                    case 'checkboxGroup':
+                                    case "multiselect":
+                                        break;
+                                    default:
+                                        // Other types use result as-is
+                                        result = String(result);
+                                        break;
+                                }
+                            }
+                            // Apply result if different from current value
+                            if (result !== null && result !== undefined && result !== formValues[component.id]) {
+                                formState.values[component.id] = result;
+                                formState.onChange(component.id, { value: result });
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Error evaluating expression for field "${fieldName}":`, error);
+                    }
+                }
+            });
+            // Update previous values for next comparison
+            Object.assign(previousValues, contextValues);
+        }
+        finally {
+            expressionEvaluationInProgressRef.current = false;
+        }
+    }, [formState?.values, processedSchema, collectAllComponents]);
     /**
      * Render a single field with label and error
      */
@@ -406,6 +473,21 @@ export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, on
         const computedReadOnly = component.readOnly || conditionalReadOnly;
         const computedDisabled = component.disabled || conditionalDisabled;
         const computedRequired = component.required || conditionalRequired;
+        // Calculate min/max constraints from minMaxRange
+        let minMaxConstraints = MinMaxRuleEngine.getConstraints(component.minMaxRange, formValues, component.type);
+        // For dateTime, also get date and time constraints separately
+        if (component.type === 'dateTime') {
+            const dateConstraints = MinMaxRuleEngine.getConstraints(component.minMaxRange, formValues, 'date');
+            const timeConstraints = MinMaxRuleEngine.getConstraints(component.minMaxTimeRange, formValues, 'time');
+            minMaxConstraints = {
+                minValue: undefined,
+                maxValue: undefined,
+                minDate: dateConstraints.minDate,
+                maxDate: dateConstraints.maxDate,
+                minTime: timeConstraints.minTime,
+                maxTime: timeConstraints.maxTime
+            };
+        }
         const labelPos = component.labelPosition || 'top';
         const labelWidth = component.labelWidth || 'auto';
         const showLabel = !component.hideLabel && component.label && !['checkbox', 'button', 'staticHtml'].includes(component.type);
@@ -448,38 +530,33 @@ export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, on
                                             justifyContent: 'center',
                                             flexShrink: 0,
                                         } }) }))] })), _jsxs("div", { className: "field-input", children: [(component.type === 'radio' || component.type === 'checkboxGroup') && Array.isArray(component.options)
-                                    ? renderFormField({
-                                        component: { ...component, readOnly: computedReadOnly, disabled: computedDisabled, required: computedRequired },
-                                        value: formState?.values[component.id],
-                                        onChange: (value) => {
+                                    ? (_jsx(RenderFormField, { component: { ...component, readOnly: computedReadOnly, disabled: computedDisabled, required: computedRequired }, value: formState?.values[component.id], onChange: (value) => {
                                             formState?.onChange(component.id, { value });
                                             if (onChange) {
                                                 onChange({ field: component.label || component.id, value });
                                             }
-                                        },
-                                        locale: formLocale,
-                                        onBlur: () => formState?.onBlur(component.id),
-                                        ref: (el, idx) => setInputRef(el, idx),
-                                        hasError,
-                                    })
-                                    : renderFormField({
-                                        component: { ...component, readOnly: computedReadOnly, disabled: computedDisabled, required: computedRequired },
-                                        value: formState?.values[component.id],
-                                        onChange: (value) => {
-                                            if (component.type !== 'dataGrid' && component.type !== 'signature' && component.type !== 'richTextEditor') {
+                                        }, locale: formLocale, onBlur: () => formState?.onBlur(component.id), ref: (el, idx) => setInputRef(el, idx), hasError: hasError }))
+                                    : (_jsx(RenderFormField, { component: {
+                                            ...component,
+                                            readOnly: computedReadOnly,
+                                            disabled: computedDisabled,
+                                            required: computedRequired,
+                                            ...(minMaxConstraints.minValue !== undefined && { minValue: minMaxConstraints.minValue }),
+                                            ...(minMaxConstraints.maxValue !== undefined && { maxValue: minMaxConstraints.maxValue }),
+                                            ...(minMaxConstraints.minDate !== undefined && { minDate: minMaxConstraints.minDate }),
+                                            ...(minMaxConstraints.maxDate !== undefined && { maxDate: minMaxConstraints.maxDate }),
+                                            ...(minMaxConstraints.minTime !== undefined && { minTime: minMaxConstraints.minTime }),
+                                            ...(minMaxConstraints.maxTime !== undefined && { maxTime: minMaxConstraints.maxTime })
+                                        }, formState: formState, value: formState?.values[component.id], onChange: (value) => {
+                                            if (component.type !== 'dataGrid' && component.type !== 'signature' && component.type !== 'richTextEditor' && component.type !== 'staticHtml') {
                                                 value = formatDateValues(component, value);
                                                 formState?.onChange(component.id, { value });
                                                 if (onChange) {
                                                     onChange({ field: component.label || component.id, value });
                                                 }
                                             }
-                                        },
-                                        locale: formLocale,
-                                        onBlur: () => { if (component.type !== 'dataGrid' && component.type !== 'richTextEditor')
-                                            formState?.onBlur(component.id); },
-                                        ref: setInputRef,
-                                        hasError,
-                                    }), hasError && _jsx("div", { className: "e-error", children: formState.errors[component.id] })] }), component.description && _jsx("div", { className: 'field-description', children: component.description })] }) }) }, component.id));
+                                        }, locale: formLocale, onBlur: () => { if (component.type !== 'dataGrid' && component.type !== 'richTextEditor' && component.type !== 'staticHtml')
+                                            formState?.onBlur(component.id); }, ref: setInputRef, hasError: hasError })), hasError && _jsx("div", { className: "e-error", children: formState.errors[component.id] })] }), component.description && _jsx("div", { className: 'field-description', children: component.description })] }) }) }, component.id));
     };
     /**
      * Render component (including layouts)
@@ -525,12 +602,7 @@ export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, on
             case 'staticHtml':
                 return (_jsx(StaticHtmlRenderer, { id: component.id, content: component.defaultValue || '<p>HTML content</p>', enableHtmlSanitizer: component.enableHtmlSanitizer }, component.id));
             case 'message':
-                return (_jsx("div", { className: "form-group", children: renderFormField({
-                        component,
-                        locale: formLocale,
-                        value: undefined,
-                        onChange: () => { },
-                    }) }, component.id));
+                return (_jsx("div", { className: "form-group", children: _jsx(RenderFormField, { component: component, locale: formLocale, value: undefined, onChange: () => { } }) }, component.id));
             case 'button':
                 const buttonlDisabled = ConditionalRuleEngine.isFieldDisabled(component.conditions, formValues);
                 const buttonComputed = component.disabled || buttonlDisabled;
@@ -542,21 +614,14 @@ export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, on
                         });
                     }
                 };
-                return (_jsx("div", { className: "form-group", children: renderFormField({
-                        component: { ...component, disabled: buttonComputed },
-                        value: undefined,
-                        onChange: () => { },
-                        locale: formLocale,
-                        onClick: (e) => { handleButtonClick(e); },
-                        ref: (el, idx) => {
+                return (_jsx("div", { className: "form-group", children: _jsx(RenderFormField, { component: { ...component, disabled: buttonComputed }, value: undefined, onChange: () => { }, locale: formLocale, onClick: (e) => { handleButtonClick(e); }, ref: (el, idx) => {
                             if (idx !== undefined) {
                                 inputRefs.current[`${component.id}_${idx}`] = el;
                             }
                             else {
                                 inputRefs.current[component.id] = el;
                             }
-                        }
-                    }) }, component.id));
+                        } }) }, component.id));
             case 'splitButton':
                 const splitButtonDisabled = ConditionalRuleEngine.isFieldDisabled(component.conditions, formValues);
                 const computedDisabled = component.disabled || splitButtonDisabled;
@@ -574,14 +639,7 @@ export const FormRenderer = React.forwardRef(({ dataSchema, uiSchema, locale, on
                         });
                     }
                 };
-                return (_jsx("div", { className: "form-group", children: renderFormField({
-                        component: { ...component, disabled: computedDisabled },
-                        value: undefined,
-                        locale: formLocale,
-                        onChange: () => { },
-                        onClick: (e) => { handleSplitButtonEvent(e); },
-                        ref: setInputRef
-                    }) }, component.id));
+                return (_jsx("div", { className: "form-group", children: _jsx(RenderFormField, { component: { ...component, disabled: computedDisabled }, value: undefined, locale: formLocale, onChange: () => { }, onClick: (e) => { handleSplitButtonEvent(e); }, ref: setInputRef }) }, component.id));
             default:
                 return renderField(component);
         }

package/src/MinMaxRuleEngine.d.ts

@@ -0,0 +1,95 @@
+export interface MinMaxRangeItem {
+    enabled: boolean;
+    minValue?: number | string | {
+        field: string;
+    };
+    maxValue?: number | string | {
+        field: string;
+    };
+}
+export interface MinMaxConstraints {
+    minValue?: number | string;
+    maxValue?: number | string;
+    minDate?: string;
+    maxDate?: string;
+    minTime?: string;
+    maxTime?: string;
+}
+export declare class MinMaxRuleEngine {
+    /**
+     * Extract min/max constraints from minMaxRange array
+     * Handles three cases:
+     * 1. Direct values (enabled: false)
+     * 2. Single field reference (enabled: true, 1 range)
+     * 3. Multiple ranges (enabled: true, 2+ ranges) - takes UTMOST
+     *
+     * @param minMaxRange - Array of range configurations
+     * @param formValues - Current form state values (id → value)
+     * @param componentType - 'number' | 'date' | 'dateRange'
+     * @returns Constraints object with appropriate keys
+     */
+    static getConstraints(minMaxRange: MinMaxRangeItem[] | undefined, formValues: Record<string, any>, componentType?: string): MinMaxConstraints;
+    /**
+     * Resolve a single value - either direct or field reference
+     *
+     * @param value - Direct value or field reference object
+     * @param formValues - Form state values for field lookup
+     * @returns Resolved value or undefined
+     */
+    private static resolveValue;
+    /**
+     * Get the most permissive (widest) minimum value
+     * For numbers: MIN of all mins
+     * For dates: earliest date (MIN string comparison on ISO format)
+     * For times: earliest time (MIN string comparison on 24-hour format)
+     *
+     * @param ranges - Array of {min, max} values
+     * @param componentType - Type of component
+     * @returns Most permissive minimum value
+     */
+    private static getPermissiveMin;
+    /**
+     * Get the most permissive (widest) maximum value
+     * For numbers: MAX of all maxs
+     * For dates: latest date (MAX string comparison on ISO format)
+     * For times: latest time (MAX string comparison on 24-hour format)
+     *
+     * @param ranges - Array of {min, max} values
+     * @param componentType - Type of component
+     * @returns Most permissive maximum value
+     */
+    private static getPermissiveMax;
+    /**
+     * Convert MM/DD/YYYY date format to ISO (YYYY-MM-DD) for comparison
+     * Handles both formats gracefully
+     *
+     * @param dateString - Date in MM/DD/YYYY or ISO format
+     * @returns ISO date string (YYYY-MM-DD)
+     */
+    private static convertToISO;
+    /**
+     * Convert 12-hour time format to 24-hour format for comparison
+     * Handles both 12-hour (hh:mm a) and 24-hour (HH:mm) formats
+     *
+     * @param timeString - Time in 12-hour (hh:mm a/p) or 24-hour (HH:mm) format
+     * @returns 24-hour format time string (HH:mm)
+     */
+    private static convertTimeTo24Hour;
+    /**
+     * Get empty constraints object based on component type
+     */
+    private static getEmptyConstraints;
+    /**
+     * Validate if a value passes all min/max constraints (optional)
+     * Can be used for client-side validation before submission
+     *
+     * @param value - Value to validate
+     * @param constraints - Constraints to check against
+     * @param componentType - Type of component
+     * @returns Validation result with error message if invalid
+     */
+    static validateValue(value: any, constraints: MinMaxConstraints, componentType: string): {
+        isValid: boolean;
+        error?: string;
+    };
+}