@rilaykit/core 0.1.1-alpha.1 → 0.1.2

package/dist/index.d.ts

@@ -1,158 +1,536 @@
-import React from 'react';
-import { z } from 'zod';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import * as React$1 from 'react';
+import React__default from 'react';
 
 /**
- * Main configuration class for Rilay form components and workflows
- * Manages component registration, retrieval, and configuration
+ * A graph that tracks which fields depend on which other fields for condition evaluation.
+ *
+ * This enables efficient re-evaluation of conditions when values change:
+ * instead of re-evaluating ALL conditions when ANY value changes,
+ * we only re-evaluate conditions that depend on the changed value.
+ *
+ * @example
+ * ```ts
+ * const graph = new ConditionDependencyGraph();
+ *
+ * // Add field with its conditions
+ * graph.addField('dependentField', {
+ *   visible: when('triggerField').equals('show')
+ * });
+ *
+ * // When 'triggerField' changes, get affected fields
+ * const affected = graph.getAffectedFields('triggerField');
+ * // affected = ['dependentField']
+ * ```
  */
-declare class ril {
-    private components;
-    private formRenderConfig;
-    private workflowRenderConfig;
-    static create(): ril;
+declare class ConditionDependencyGraph {
     /**
-     * Add a component to the configuration
-     * @param subType - The component subtype (e.g., 'text', 'email', 'heading')
-     * @param config - Component configuration without id and subType
-     * @returns The ril instance for chaining
+     * Maps field IDs to their dependencies (fields they depend on)
+     * fieldId -> Set of field paths it depends on
      */
-    addComponent<TProps = any>(subType: InputType | LayoutType, config: Omit<ComponentConfig<TProps>, 'id' | 'subType'> & {
-        id?: string;
-    }): this;
+    private readonly fieldDependencies;
     /**
-     * Set custom row renderer
-     * @param renderer - Custom row renderer function
-     * @returns The ril instance for chaining
+     * Reverse index: maps a field path to all fields that depend on it
+     * fieldPath -> Set of field IDs that have conditions depending on this path
      */
-    setRowRenderer(renderer: FormRowRenderer): this;
+    private readonly reverseDependencies;
     /**
-     * Set custom body renderer
-     * @param renderer - Custom body renderer function
-     * @returns The ril instance for chaining
+     * Adds a field with its conditional behavior to the graph.
+     *
+     * @param fieldId - The ID of the field
+     * @param conditions - The field's conditional behavior (visible, disabled, required, readonly)
      */
-    setBodyRenderer(renderer: FormBodyRenderer): this;
+    addField(fieldId: string, conditions?: ConditionalBehavior): void;
     /**
-     * Set custom submit button renderer
-     * @param renderer - Custom submit button renderer function
-     * @returns The ril instance for chaining
+     * Removes a field from the graph.
+     *
+     * @param fieldId - The ID of the field to remove
      */
-    setSubmitButtonRenderer(renderer: FormSubmitButtonRenderer): this;
+    removeField(fieldId: string): void;
     /**
-     * Set complete form render configuration
-     * @param config - Form render configuration
-     * @returns The ril instance for chaining
+     * Gets all field IDs that have conditions depending on a specific field path.
+     *
+     * When a value at `changedPath` changes, these are the fields whose
+     * conditions need to be re-evaluated.
+     *
+     * @param changedPath - The field path that changed
+     * @returns Array of field IDs that depend on this path
      */
-    setFormRenderConfig(config: FormRenderConfig): this;
+    getAffectedFields(changedPath: string): string[];
     /**
-     * Get current form render configuration
-     * @returns Current form render configuration
+     * Gets all field IDs affected by changes to multiple paths.
+     *
+     * @param changedPaths - Array of field paths that changed
+     * @returns Array of unique field IDs that depend on any of these paths
      */
-    getFormRenderConfig(): FormRenderConfig;
+    getAffectedFieldsMultiple(changedPaths: string[]): string[];
     /**
-     * Set custom stepper renderer for workflows
-     * @param renderer - Custom stepper renderer function
-     * @returns The ril instance for chaining
+     * Gets the dependencies for a specific field.
+     *
+     * @param fieldId - The ID of the field
+     * @returns Array of field paths this field depends on
      */
-    setStepperRenderer(renderer: WorkflowStepperRenderer): this;
+    getDependencies(fieldId: string): string[];
     /**
-     * Set custom workflow navigation renderer
-     * @param renderer - Custom workflow navigation renderer function
-     * @returns The ril instance for chaining
+     * Checks if a field has any dependencies.
+     *
+     * @param fieldId - The ID of the field
+     * @returns True if the field has conditional dependencies
      */
-    setWorkflowNavigationRenderer(renderer: WorkflowNavigationRenderer): this;
+    hasDependencies(fieldId: string): boolean;
     /**
-     * Set complete workflow render configuration
-     * @param config - Workflow render configuration
-     * @returns The ril instance for chaining
+     * Gets all fields in the graph.
+     *
+     * @returns Array of all field IDs
      */
-    setWorkflowRenderConfig(config: WorkflowRenderConfig): this;
+    getAllFields(): string[];
     /**
-     * Get current workflow render configuration
-     * @returns Current workflow render configuration
+     * Gets all unique dependency paths in the graph.
+     *
+     * @returns Array of all field paths that are dependencies
      */
-    getWorkflowRenderConfig(): WorkflowRenderConfig;
+    getAllDependencyPaths(): string[];
     /**
-     * @deprecated Use setFormRenderConfig() instead
+     * Clears the entire graph.
      */
-    setRenderConfig(config: FormRenderConfig): this;
+    clear(): void;
     /**
-     * Get a component by its ID
-     * @param id - Component ID
-     * @returns Component configuration or undefined
+     * Gets the size of the graph (number of fields).
      */
-    getComponent(id: string): ComponentConfig | undefined;
+    get size(): number;
     /**
-     * List components by type (input or layout)
-     * @param type - Component type
-     * @returns Array of matching components
+     * Creates a debug representation of the graph.
+     * Useful for development and testing.
      */
-    getComponentsByType(type: ComponentType): ComponentConfig[];
+    toDebugObject(): {
+        fields: Record<string, string[]>;
+        reverseDeps: Record<string, string[]>;
+    };
+}
+
+type ConditionOperator = 'equals' | 'notEquals' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'contains' | 'notContains' | 'in' | 'notIn' | 'matches' | 'exists' | 'notExists';
+type LogicalOperator = 'and' | 'or';
+type ConditionValue = string | number | boolean | null | undefined | Array<string | number | boolean>;
+interface ConditionConfig {
+    field: string;
+    operator: ConditionOperator;
+    value?: ConditionValue;
+    conditions?: ConditionConfig[];
+    logicalOperator?: LogicalOperator;
+}
+type ConditionEvaluator = (data: Record<string, any>) => boolean;
+interface ConditionBuilder extends ConditionConfig {
+    equals(value: ConditionValue): ConditionBuilder;
+    notEquals(value: ConditionValue): ConditionBuilder;
+    greaterThan(value: number): ConditionBuilder;
+    lessThan(value: number): ConditionBuilder;
+    greaterThanOrEqual(value: number): ConditionBuilder;
+    lessThanOrEqual(value: number): ConditionBuilder;
+    contains(value: string): ConditionBuilder;
+    notContains(value: string): ConditionBuilder;
+    in(values: Array<string | number | boolean>): ConditionBuilder;
+    notIn(values: Array<string | number | boolean>): ConditionBuilder;
+    matches(pattern: string | RegExp): ConditionBuilder;
+    exists(): ConditionBuilder;
+    notExists(): ConditionBuilder;
+    and(condition: ConditionBuilder | ConditionConfig): ConditionBuilder;
+    or(condition: ConditionBuilder | ConditionConfig): ConditionBuilder;
+    build(): ConditionConfig;
+    evaluate(data: Record<string, any>): boolean;
+}
+declare function when(field: string): ConditionBuilder;
+declare function evaluateCondition(condition: ConditionConfig, data: Record<string, any>): boolean;
+
+/**
+ * Extracts all field paths that a condition depends on.
+ *
+ * This is useful for building a dependency graph that knows which
+ * conditions need to be re-evaluated when a specific field changes.
+ *
+ * @param condition - The condition to extract dependencies from
+ * @returns An array of unique field paths
+ *
+ * @example
+ * ```ts
+ * const condition = when('field1').equals('value').and(when('field2').exists());
+ * const deps = extractConditionDependencies(condition.build());
+ * // deps = ['field1', 'field2']
+ *
+ * const nestedCondition = when('step1.field1').equals('value');
+ * const nestedDeps = extractConditionDependencies(nestedCondition.build());
+ * // nestedDeps = ['step1.field1']
+ * ```
+ */
+declare function extractConditionDependencies(condition: ConditionConfig | ConditionBuilder | undefined | null): string[];
+/**
+ * Extracts dependencies from multiple conditions (e.g., visible, disabled, required).
+ *
+ * @param behaviors - Object containing condition configurations
+ * @returns An array of unique field paths from all conditions
+ */
+declare function extractAllDependencies(behaviors: Record<string, ConditionConfig | ConditionBuilder | undefined | null>): string[];
+
+/**
+ * Validation result for async operations
+ */
+interface AsyncValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings?: string[];
+}
+/**
+ * Public interface for Rilay instances
+ * Exposes only the methods necessary for the public API
+ */
+interface RilayInstance<C> {
+    addComponent<NewType extends string, TProps = any>(type: NewType, config: Omit<ComponentConfig<TProps>, 'id' | 'type'>): RilayInstance<C & {
+        [K in NewType]: TProps;
+    }>;
+    configure(config: Partial<FormRenderConfig & WorkflowRenderConfig>): RilayInstance<C>;
+    getComponent<T extends keyof C & string>(id: T): ComponentConfig<C[T]> | undefined;
+    getComponent(id: string): ComponentConfig | undefined;
+    getAllComponents(): ComponentConfig[];
+    hasComponent(id: string): boolean;
+    getFormRenderConfig(): FormRenderConfig;
+    getWorkflowRenderConfig(): WorkflowRenderConfig;
+    getStats(): {
+        total: number;
+        byType: Record<string, number>;
+        hasCustomRenderers: {
+            row: boolean;
+            body: boolean;
+            submitButton: boolean;
+            field: boolean;
+            repeatable: boolean;
+            repeatableItem: boolean;
+            stepper: boolean;
+            workflowNextButton: boolean;
+            workflowPreviousButton: boolean;
+            workflowSkipButton: boolean;
+        };
+    };
+    validate(): string[];
+    validateAsync(): Promise<AsyncValidationResult>;
+    clone(): RilayInstance<C>;
+    removeComponent(id: string): RilayInstance<C>;
+    clear(): RilayInstance<C>;
+}
+/**
+ * Main configuration class for Rilay form components and workflows
+ * Manages component registration, retrieval, and configuration with immutable API
+ */
+declare class ril<C> implements RilayInstance<C> {
+    private components;
+    private formRenderConfig;
+    private workflowRenderConfig;
     /**
-     * List components by sub-type
-     * @param subType - Component sub-type
-     * @returns Array of matching components
+     * Static factory method to create a new ril instance
      */
-    getComponentsBySubType(subType: InputType | LayoutType): ComponentConfig[];
+    static create<CT>(): ril<CT>;
     /**
-     * Get components by category
-     * @param category - Component category
-     * @returns Array of matching components
+     * Add a component to the configuration (immutable)
+     * Returns a new instance with the added component
+     *
+     * @param type - The component type (e.g., 'text', 'email', 'heading'), used as a unique identifier.
+     * @param config - Component configuration without id and type
+     * @returns A new ril instance with the added component
+     *
+     * @example
+     * ```typescript
+     * // Component with default validation
+     * const factory = ril.create()
+     *   .addComponent('email', {
+     *     name: 'Email Input',
+     *     renderer: EmailInput,
+     *     validation: {
+     *       validators: [email('Format email invalide')],
+     *       validateOnBlur: true,
+     *     }
+     *   });
+     * ```
      */
-    getComponentsByCategory(category: string): ComponentConfig[];
+    addComponent<NewType extends string, TProps = any>(type: NewType, config: Omit<ComponentConfig<TProps>, 'id' | 'type'>): ril<C & {
+        [K in NewType]: TProps;
+    }>;
     /**
-     * List all registered components
-     * @returns Array of all components
+     * Universal configuration method with deep merge support (immutable)
+     *
+     * This method provides a unified API to configure both form and workflow renderers
+     * in a single call, automatically categorizing and applying the appropriate configurations
+     * using recursive deep merge.
+     *
+     * @param config - Configuration object containing renderer settings
+     * @returns A new ril instance with the updated configuration
+     *
+     * @example
+     * ```typescript
+     * // Configure with nested settings
+     * const config = ril.create()
+     *   .configure({
+     *     rowRenderer: CustomRowRenderer,
+     *     submitButtonRenderer: CustomSubmitButton,
+     *     // Deep nested configuration example
+     *     formStyles: {
+     *       layout: {
+     *         spacing: 'large',
+     *         alignment: 'center'
+     *       }
+     *     }
+     *   });
+     * ```
      */
-    getAllComponents(): ComponentConfig[];
+    configure(config: Partial<FormRenderConfig & WorkflowRenderConfig>): ril<C>;
     /**
-     * Check if a component exists
-     * @param id - Component ID
-     * @returns True if component exists
+     * Configuration getters
      */
-    hasComponent(id: string): boolean;
+    getFormRenderConfig(): FormRenderConfig;
+    getWorkflowRenderConfig(): WorkflowRenderConfig;
     /**
-     * Remove a component from the configuration
-     * @param id - Component ID
-     * @returns True if component was removed
+     * Component management methods
      */
-    removeComponent(id: string): boolean;
+    getComponent<T extends keyof C & string>(id: T): ComponentConfig<C[T]> | undefined;
+    getAllComponents(): ComponentConfig[];
+    hasComponent(id: string): boolean;
     /**
-     * Clear all components
+     * Remove a component from the configuration (immutable)
+     * Returns a new instance without the specified component
+     *
+     * @param id - The component ID to remove
+     * @returns A new ril instance without the component
      */
-    clear(): void;
+    removeComponent(id: string): ril<C>;
     /**
-     * Export configuration as a plain object
-     * @returns Object with component configurations
+     * Clear all components from the configuration (immutable)
+     * Returns a new instance with no components
+     *
+     * @returns A new empty ril instance
      */
-    export(): Record<string, ComponentConfig>;
+    clear(): ril<C>;
     /**
-     * Import configuration from a plain object
-     * @param config - Object with component configurations
-     * @returns The ril instance for chaining
+     * Create a deep copy of the current ril instance
      */
-    import(config: Record<string, ComponentConfig>): this;
+    clone(): ril<C>;
     /**
-     * Get statistics about registered components and renderers
-     * @returns Object with comprehensive statistics
+     * Enhanced statistics with more detailed information
      */
     getStats(): {
         total: number;
-        byType: Record<ComponentType, number>;
-        bySubType: Record<string, number>;
-        byCategory: Record<string, number>;
+        byType: Record<string, number>;
         hasCustomRenderers: {
             row: boolean;
             body: boolean;
             submitButton: boolean;
+            field: boolean;
+            repeatable: boolean;
+            repeatableItem: boolean;
             stepper: boolean;
-            workflowNavigation: boolean;
+            workflowNextButton: boolean;
+            workflowPreviousButton: boolean;
+            workflowSkipButton: boolean;
         };
     };
     /**
-     * Validate the configuration
-     * @returns Array of validation errors
+     * Synchronous validation using shared utilities
      */
     validate(): string[];
+    /**
+     * Asynchronous validation with structured error handling
+     * Ideal for CI/CD pipelines and advanced validation scenarios
+     */
+    validateAsync(): Promise<AsyncValidationResult>;
+}
+
+type ValidationState = 'idle' | 'validating' | 'valid' | 'invalid';
+/**
+ * Field state without actions - used for selectors
+ */
+interface FieldState {
+    readonly value: unknown;
+    readonly errors: ValidationError[];
+    readonly validationState: ValidationState;
+    readonly touched: boolean;
+    readonly dirty: boolean;
+}
+/**
+ * Field conditions - visibility, disabled, required, readonly
+ */
+interface FieldConditions {
+    readonly visible: boolean;
+    readonly disabled: boolean;
+    readonly required: boolean;
+    readonly readonly: boolean;
+}
+/**
+ * Field actions - stable references for setValue, validate, etc.
+ */
+interface FieldActions {
+    readonly setValue: (value: unknown) => void;
+    readonly setTouched: () => void;
+    readonly validate: () => Promise<ValidationResult>;
+    readonly clearErrors: () => void;
+}
+/**
+ * Complete field context - combines state, conditions and actions
+ * Used by component renderers for full field access
+ */
+interface FieldContext extends FieldState, FieldConditions {
+    readonly id: string;
+    readonly componentId: string;
+    readonly defaultValue?: unknown;
+    readonly actions: FieldActions;
+}
+/**
+ * Form state without actions - used for selectors
+ */
+interface FormState {
+    readonly values: Record<string, unknown>;
+    readonly errors: Record<string, ValidationError[]>;
+    readonly validationStates: Record<string, ValidationState>;
+    readonly touched: Record<string, boolean>;
+    readonly isDirty: boolean;
+    readonly isSubmitting: boolean;
+    readonly isValid: boolean;
+}
+/**
+ * Form actions - stable references
+ */
+interface FormActions {
+    readonly setValue: (fieldId: string, value: unknown) => void;
+    readonly setTouched: (fieldId: string) => void;
+    readonly setErrors: (fieldId: string, errors: ValidationError[]) => void;
+    readonly setValidationState: (fieldId: string, state: ValidationState) => void;
+    readonly setSubmitting: (isSubmitting: boolean) => void;
+    readonly submit: () => Promise<boolean>;
+    readonly reset: (values?: Record<string, unknown>) => void;
+    readonly validate: () => Promise<ValidationResult>;
+    readonly validateField: (fieldId: string, value?: unknown) => Promise<ValidationResult>;
+}
+/**
+ * Complete form context - combines state and actions
+ */
+interface FormContextValue extends FormState {
+    readonly formId: string;
+    readonly actions: FormActions;
+    readonly getFieldState: (fieldId: string) => FieldState;
+    readonly getFieldConditions: (fieldId: string) => FieldConditions;
+}
+/**
+ * Props passed to component renderers (v2)
+ * Replaces the old ComponentRenderProps with spread [key: string]: any
+ */
+interface ComponentRenderPropsV2<TProps = unknown> {
+    /** Field identifier */
+    readonly id: string;
+    /** Component-specific props (label, placeholder, options, etc.) */
+    readonly props: TProps;
+    /** Field state (value, errors, touched, etc.) */
+    readonly field: FieldState;
+    /** Field conditions (visible, disabled, required, readonly) */
+    readonly conditions: FieldConditions;
+    /** Stable action references */
+    readonly actions: FieldActions;
+}
+/**
+ * Props passed to field wrapper renderers (v2)
+ */
+interface FieldRendererPropsV2 {
+    /** Rendered component content */
+    readonly children: React.ReactNode;
+    /** Field identifier */
+    readonly id: string;
+    /** Field state */
+    readonly field: FieldState;
+    /** Field conditions */
+    readonly conditions: FieldConditions;
+    /** Component props (for label, placeholder, helpText, etc.) */
+    readonly componentProps: Record<string, unknown>;
+}
+/**
+ * Props passed to form submit button renderer (v2)
+ */
+interface FormSubmitButtonRendererPropsV2 {
+    /** Whether form is currently submitting */
+    readonly isSubmitting: boolean;
+    /** Whether form is valid (no errors) */
+    readonly isValid: boolean;
+    /** Whether form has been modified */
+    readonly isDirty: boolean;
+    /** Submit handler */
+    readonly onSubmit: () => void;
+    /** Reset handler */
+    readonly onReset: () => void;
+    /** Form data access (for advanced use cases) */
+    readonly form: {
+        readonly values: Record<string, unknown>;
+        readonly errors: Record<string, ValidationError[]>;
+    };
+    /** Optional className */
+    readonly className?: string;
+    /** Optional children */
+    readonly children?: React.ReactNode;
+}
+/**
+ * Step state for workflow
+ */
+interface WorkflowStepState {
+    readonly stepIndex: number;
+    readonly stepId: string;
+    readonly isFirst: boolean;
+    readonly isLast: boolean;
+    readonly isVisible: boolean;
+    readonly isSkippable: boolean;
+}
+/**
+ * Navigation state for workflow
+ */
+interface WorkflowNavigationState {
+    readonly canGoNext: boolean;
+    readonly canGoPrevious: boolean;
+    readonly canSkip: boolean;
+    readonly isTransitioning: boolean;
+}
+/**
+ * Progress state for workflow
+ */
+interface WorkflowProgressState {
+    readonly totalSteps: number;
+    readonly visibleSteps: number;
+    readonly currentStepIndex: number;
+    readonly visitedSteps: ReadonlySet<string>;
+    readonly passedSteps: ReadonlySet<string>;
+}
+/**
+ * Complete workflow step context
+ */
+interface WorkflowStepContext {
+    readonly step: WorkflowStepState;
+    readonly navigation: WorkflowNavigationState;
+    readonly progress: WorkflowProgressState;
+    readonly stepData: Record<string, unknown>;
+    readonly allData: Record<string, unknown>;
+}
+/**
+ * Props passed to workflow button renderers (v2)
+ */
+interface WorkflowButtonRendererPropsV2 {
+    /** Navigation state */
+    readonly navigation: WorkflowNavigationState;
+    /** Progress state */
+    readonly progress: WorkflowProgressState;
+    /** Current step state */
+    readonly step: WorkflowStepState;
+    /** Whether workflow is submitting */
+    readonly isSubmitting: boolean;
+    /** Step data */
+    readonly stepData: Record<string, unknown>;
+    /** All workflow data */
+    readonly allData: Record<string, unknown>;
+    /** Action handler (next/previous/skip/submit) */
+    readonly onAction: () => void;
+    /** Optional className */
+    readonly className?: string;
+    /** Optional children */
+    readonly children?: React.ReactNode;
 }
 
 interface RilayLicenseConfig {
@@ -160,103 +538,330 @@ interface RilayLicenseConfig {
     readonly environment?: 'development' | 'production';
     readonly allowTrial?: boolean;
 }
-type ComponentType = 'input' | 'layout';
-type InputType = 'text' | 'email' | 'password' | 'number' | 'select' | 'checkbox' | 'textarea' | 'file' | 'date';
-type LayoutType = 'heading' | 'paragraph' | 'container' | 'divider' | 'spacer' | 'alert';
-interface ValidationResult {
-    readonly isValid: boolean;
-    readonly errors: ValidationError[];
-    readonly warnings?: ValidationWarning[];
-}
 interface ValidationError {
-    readonly code: string;
     readonly message: string;
-    readonly path?: string[];
+    readonly code?: string;
+    readonly path?: string;
 }
-interface ValidationWarning {
-    readonly code: string;
-    readonly message: string;
-    readonly path?: string[];
+interface ValidationResult {
+    readonly isValid: boolean;
+    readonly errors: ValidationError[];
+    readonly value?: any;
 }
 interface ValidationContext {
-    readonly fieldId: string;
-    readonly formData: Record<string, any>;
-    readonly fieldProps: Record<string, any>;
-    readonly touched: boolean;
-    readonly dirty: boolean;
+    readonly fieldId?: string;
+    readonly formId?: string;
+    readonly stepId?: string;
+    readonly workflowId?: string;
+    readonly allFormData?: Record<string, any>;
+    readonly stepData?: Record<string, any>;
+    readonly workflowData?: Record<string, any>;
 }
-type ValidatorFunction<TProps = any> = (value: any, context: ValidationContext, props: TProps) => ValidationResult | Promise<ValidationResult>;
-interface ValidationConfig<TProps = any> {
-    readonly validator?: ValidatorFunction<TProps>;
-    readonly debounceMs?: number;
+/** @internal - Use Standard Schema instead */
+type FieldValidator<T = any> = (value: T, context: ValidationContext) => ValidationResult | Promise<ValidationResult>;
+/** @internal - Use Standard Schema instead */
+type FormValidator<T = Record<string, any>> = (formData: T, context: ValidationContext) => ValidationResult | Promise<ValidationResult>;
+type StandardSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output>;
+type InferInput<T> = T extends StandardSchema<infer I, any> ? I : unknown;
+type InferOutput<T> = T extends StandardSchema<any, infer O> ? O : unknown;
+interface FieldValidationConfig<T = any> {
+    /**
+     * Validation rules using Standard Schema interface
+     * Accepts: single schema, array of schemas, or any Standard Schema compatible validation
+     *
+     * @example Single schema
+     * validate: z.string().email()
+     *
+     * @example Built-in validators
+     * validate: required()
+     *
+     * @example Multiple validations
+     * validate: [required(), email()]
+     *
+     * @example Mixed schemas + validators
+     * validate: [z.string(), required(), customValidator()]
+     */
+    readonly validate?: StandardSchema<T> | StandardSchema<T>[];
     readonly validateOnChange?: boolean;
     readonly validateOnBlur?: boolean;
+    readonly debounceMs?: number;
+}
+interface FormValidationConfig<T extends Record<string, any> = Record<string, any>> {
+    /**
+     * Form-level validation using Standard Schema interface
+     *
+     * @example Object schema
+     * validate: z.object({ email: z.string().email(), name: z.string() })
+     *
+     * @example Custom form validator
+     * validate: customFormValidator()
+     */
+    readonly validate?: StandardSchema<T> | StandardSchema<T>[];
     readonly validateOnSubmit?: boolean;
-    readonly dependencies?: string[];
+    readonly validateOnStepChange?: boolean;
+}
+type ComponentRenderer<TProps = any> = (props: ComponentRenderProps<TProps>) => React__default.ReactElement;
+type RendererChildrenFunction<TProps = any> = (props: TProps) => React__default.ReactNode;
+interface ComponentRendererBaseProps<TProps = any> {
+    className?: string;
+    children?: React__default.ReactNode | RendererChildrenFunction<TProps>;
+    renderAs?: 'default' | 'children' | boolean;
+}
+interface ComponentRendererWrapperProps<TProps = any> extends Omit<ComponentRendererBaseProps<TProps>, 'className'> {
+    name: string;
+    props: TProps;
+    renderer?: RendererChildrenFunction<TProps>;
 }
-type ComponentRenderer<TProps = any> = (props: ComponentRenderProps<TProps>) => React.ReactElement;
 interface ComponentRenderProps<TProps = any> {
     id: string;
     props: TProps;
     value?: any;
     onChange?: (value: any) => void;
     onBlur?: () => void;
-    error?: ValidationError[];
-    warnings?: ValidationWarning[];
-    touched?: boolean;
     disabled?: boolean;
+    error?: ValidationError[];
     isValidating?: boolean;
     [key: string]: any;
 }
-interface ComponentOptions<TProps = any> {
-    readonly configurable?: Array<{
-        key: keyof TProps;
-        type: 'string' | 'number' | 'boolean' | 'select' | 'array';
+/**
+ * Property editor definition for builder property panel
+ * Generic and extensible to support any custom editor type
+ */
+interface PropertyEditorDefinition<TValue = any> {
+    /** Property key in component props */
+    readonly key: string;
+    /** Display label in property panel */
+    readonly label: string;
+    /**
+     * Editor type - can be any string to support custom editors
+     * Built-in types: 'text', 'number', 'boolean', 'select', 'multiselect', 'color', 'textarea', 'json'
+     * Custom types: 'phone', 'currency', 'location', 'rating', 'file-upload', etc.
+     */
+    readonly editorType: string;
+    /** Optional description/help text */
+    readonly helpText?: string;
+    /** Default value for this property */
+    readonly defaultValue?: TValue;
+    /** Options for select/multiselect editors */
+    readonly options?: Array<{
         label: string;
-        options?: any[];
-        default?: any;
+        value: any;
+        [key: string]: any;
     }>;
-    readonly previewProps?: Partial<TProps>;
+    /** Validation function for the property value */
+    readonly validate?: (value: TValue) => boolean | string | Promise<boolean | string>;
+    /** Group/section for organizing properties */
+    readonly group?: string;
+    /** Whether this property is required */
+    readonly required?: boolean;
+    /** Placeholder text for input fields */
+    readonly placeholder?: string;
+    /** Custom editor component for advanced use cases */
+    readonly customEditor?: React__default.ComponentType<PropertyEditorProps<TValue>>;
+    /** Additional configuration specific to the editor type */
+    readonly editorConfig?: Record<string, any>;
+    /** Dependencies - other properties that affect this one */
+    readonly dependencies?: string[];
+    /** Conditional rendering based on other property values */
+    readonly visible?: (props: Record<string, any>) => boolean;
+    /** Transform value before saving */
+    readonly transform?: (value: TValue) => any;
+    /** Parse value when loading */
+    readonly parse?: (value: any) => TValue;
+}
+/**
+ * Props passed to custom property editors
+ */
+interface PropertyEditorProps<TValue = any> {
+    /** Current property value */
+    readonly value: TValue;
+    /** Callback to update the value */
+    readonly onChange: (value: TValue) => void;
+    /** Property definition */
+    readonly definition: PropertyEditorDefinition<TValue>;
+    /** All current property values (for dependencies) */
+    readonly allValues: Record<string, any>;
+    /** Whether the field is disabled */
+    readonly disabled?: boolean;
+    /** Validation errors */
+    readonly errors?: string[];
+}
+/**
+ * Builder metadata for visual editing capabilities
+ * This is optional and only used by @rilaykit/builder
+ * Fully generic to support any component type and configuration
+ */
+interface ComponentBuilderMetadata<TProps = any> {
+    /** Category for grouping in component palette (e.g., 'Input', 'Layout', 'Advanced') */
+    readonly category?: string;
+    /** Icon identifier (e.g., 'text', 'email', 'calendar') */
     readonly icon?: string;
+    /** Whether this component should be hidden from the builder palette */
+    readonly hidden?: boolean;
+    /** Preview component or description for the palette */
+    readonly preview?: React__default.ReactNode;
+    /** Editable properties configuration for property panel */
+    readonly editableProps?: PropertyEditorDefinition[];
+    /** Tags for search and filtering */
     readonly tags?: string[];
+    /**
+     * Custom field schema for advanced type systems
+     * Allows defining complex field types with their own validation and structure
+     */
+    readonly fieldSchema?: FieldSchemaDefinition<TProps>;
+}
+/**
+ * Field schema definition for complex field types
+ * Supports defining custom field types with validation, defaults, and metadata
+ */
+interface FieldSchemaDefinition<TProps = any> {
+    /** Field type identifier (e.g., 'location', 'phone', 'currency') */
+    readonly type: string;
+    /** Schema validation (Zod, Yup, or any Standard Schema) */
+    readonly schema?: any;
+    /** Default configuration for this field type */
+    readonly defaultConfig?: Partial<TProps>;
+    /** Sub-fields for complex types (e.g., Location has address, city, country) */
+    readonly subFields?: Array<{
+        key: string;
+        label: string;
+        type: string;
+        required?: boolean;
+    }>;
+    /** Custom serialization for complex data structures */
+    readonly serialize?: (value: any) => any;
+    /** Custom deserialization for complex data structures */
+    readonly deserialize?: (value: any) => any;
 }
 interface ComponentConfig<TProps = any> {
     readonly id: string;
-    readonly type: ComponentType;
-    readonly subType: InputType | LayoutType;
+    readonly type: string;
     readonly name: string;
     readonly description?: string;
-    readonly category?: string;
     readonly renderer: ComponentRenderer<TProps>;
-    readonly options?: ComponentOptions<TProps>;
-    readonly validation?: ValidationConfig<TProps>;
     readonly defaultProps?: Partial<TProps>;
+    readonly useFieldRenderer?: boolean;
+    readonly validation?: FieldValidationConfig;
+    /** Optional builder metadata for visual editing (only used by @rilaykit/builder) */
+    readonly builder?: ComponentBuilderMetadata;
+}
+interface ConditionalBehavior {
+    readonly visible?: ConditionConfig;
+    readonly disabled?: ConditionConfig;
+    readonly required?: ConditionConfig;
+    readonly readonly?: ConditionConfig;
+}
+interface StepConditionalBehavior {
+    readonly visible?: ConditionConfig;
+    readonly skippable?: ConditionConfig;
 }
 interface FormFieldConfig {
     readonly id: string;
     readonly componentId: string;
     readonly props: Record<string, any>;
-    readonly validation?: ValidationConfig;
-    readonly conditional?: ConditionalConfig;
+    readonly validation?: FieldValidationConfig;
+    readonly conditions?: ConditionalBehavior;
 }
 interface FormFieldRow {
+    readonly kind: 'fields';
     readonly id: string;
     readonly fields: FormFieldConfig[];
     readonly maxColumns?: number;
-    readonly spacing?: 'tight' | 'normal' | 'loose';
-    readonly alignment?: 'start' | 'center' | 'end' | 'stretch';
 }
-interface ConditionalConfig {
-    readonly condition: (formData: Record<string, any>) => boolean;
-    readonly action: 'show' | 'hide' | 'disable' | 'require';
+interface RepeatableFieldConfig {
+    readonly id: string;
+    readonly rows: FormFieldRow[];
+    readonly allFields: FormFieldConfig[];
+    readonly min?: number;
+    readonly max?: number;
+    readonly defaultValue?: Record<string, unknown>;
+    readonly validation?: FieldValidationConfig;
+}
+interface RepeatableFieldItem {
+    readonly key: string;
+    readonly index: number;
+    readonly rows: FormFieldRow[];
+    readonly allFields: FormFieldConfig[];
+}
+interface FormRepeatableRow {
+    readonly kind: 'repeatable';
+    readonly id: string;
+    readonly repeatable: RepeatableFieldConfig;
+}
+type FormRowEntry = FormFieldRow | FormRepeatableRow;
+interface RepeatableFieldRendererProps {
+    readonly repeatableId: string;
+    readonly items: RepeatableFieldItem[];
+    readonly canAdd: boolean;
+    readonly canRemove: boolean;
+    readonly onAdd: () => void;
+    readonly min?: number;
+    readonly max?: number;
+    readonly children: React__default.ReactNode;
 }
-interface StepLifecycleHooks {
-    readonly onBeforeEnter?: (stepData: any, allData: any, context: WorkflowContext) => Promise<void>;
-    readonly onAfterLeave?: (stepData: any, allData: any, context: WorkflowContext) => Promise<boolean>;
-    readonly onValidate?: (stepData: any, context: WorkflowContext) => Promise<ValidationResult>;
-    readonly onTransform?: (stepData: any, context: WorkflowContext) => Promise<any>;
-    readonly onError?: (error: Error, context: WorkflowContext) => Promise<void>;
+interface RepeatableItemRendererProps {
+    readonly item: RepeatableFieldItem;
+    readonly index: number;
+    readonly total: number;
+    readonly canRemove: boolean;
+    readonly canMoveUp: boolean;
+    readonly canMoveDown: boolean;
+    readonly onRemove: () => void;
+    readonly onMoveUp: () => void;
+    readonly onMoveDown: () => void;
+    readonly children: React__default.ReactNode;
 }
+type RepeatableFieldRenderer = RendererChildrenFunction<RepeatableFieldRendererProps>;
+type RepeatableItemRenderer = RendererChildrenFunction<RepeatableItemRendererProps>;
+interface FormConfiguration<C extends Record<string, any> = Record<string, never>> {
+    readonly id: string;
+    readonly config: ril<C>;
+    readonly rows: FormRowEntry[];
+    readonly allFields: FormFieldConfig[];
+    readonly repeatableFields?: Record<string, RepeatableFieldConfig>;
+    readonly renderConfig?: FormRenderConfig;
+    readonly validation?: FormValidationConfig;
+}
+interface FormRenderConfig {
+    readonly rowRenderer?: FormRowRenderer;
+    readonly bodyRenderer?: FormBodyRenderer;
+    readonly submitButtonRenderer?: FormSubmitButtonRenderer;
+    readonly fieldRenderer?: FieldRenderer;
+    readonly repeatableRenderer?: RepeatableFieldRenderer;
+    readonly repeatableItemRenderer?: RepeatableItemRenderer;
+}
+interface FormComponentRendererProps {
+    children: React__default.ReactNode;
+}
+interface FormRowRendererProps {
+    row: FormFieldRow;
+    children: React__default.ReactNode;
+    className?: string;
+}
+interface FormBodyRendererProps {
+    formConfig: FormConfiguration;
+    children: React__default.ReactNode;
+    className?: string;
+}
+interface FormSubmitButtonRendererProps {
+    isSubmitting: boolean;
+    onSubmit: () => void;
+    className?: string;
+    children?: React__default.ReactNode;
+}
+interface FieldRendererProps {
+    children: React__default.ReactNode;
+    id: string;
+    disabled?: boolean;
+    error?: ValidationError[];
+    isValidating?: boolean;
+    touched?: boolean;
+    [key: string]: any;
+}
+type FormRowRenderer = RendererChildrenFunction<FormRowRendererProps>;
+type FormBodyRenderer = RendererChildrenFunction<FormBodyRendererProps>;
+type FormSubmitButtonRenderer = RendererChildrenFunction<FormSubmitButtonRendererProps>;
+type FieldRenderer = RendererChildrenFunction<FieldRendererProps>;
 interface WorkflowContext {
     readonly workflowId: string;
     readonly currentStepIndex: number;
@@ -266,85 +871,70 @@ interface WorkflowContext {
     readonly isFirstStep: boolean;
     readonly isLastStep: boolean;
     readonly visitedSteps: Set<string>;
-    readonly user?: any;
-}
-interface StepPermissions {
-    readonly requiredRoles?: string[];
-    readonly requiredPermissions?: string[];
-    readonly customGuard?: (user: any, context: WorkflowContext) => boolean | Promise<boolean>;
-}
-interface DynamicStepConfig {
-    readonly resolver: (previousData: any, context: WorkflowContext) => Promise<StepConfig[]>;
-    readonly cacheKey?: string;
-    readonly retryPolicy?: RetryPolicy;
+    readonly visibleVisitedSteps: Set<string>;
+    readonly passedSteps: Set<string>;
 }
-interface RetryPolicy {
-    readonly maxRetries: number;
-    readonly delayMs: number;
-    readonly backoffMultiplier?: number;
-}
-interface ConditionalBranch {
-    readonly condition: (data: any, context: WorkflowContext) => boolean | Promise<boolean>;
-    readonly steps: StepConfig[];
-    readonly fallback?: StepConfig[];
+interface StepDataHelper {
+    /**
+     * Set data for a specific step by step ID
+     */
+    setStepData: (stepId: string, data: Record<string, any>) => void;
+    /**
+     * Set specific field values for a step
+     */
+    setStepFields: (stepId: string, fields: Record<string, any>) => void;
+    /**
+     * Get current data for a specific step
+     */
+    getStepData: (stepId: string) => Record<string, any>;
+    /**
+     * Set field value for the next step
+     */
+    setNextStepField: (fieldId: string, value: any) => void;
+    /**
+     * Set multiple fields for the next step
+     */
+    setNextStepFields: (fields: Record<string, any>) => void;
+    /**
+     * Get all workflow data
+     */
+    getAllData: () => Record<string, any>;
+    /**
+     * Get all step configurations for reference
+     */
+    getSteps: () => StepConfig[];
 }
 interface StepConfig {
     readonly id: string;
     readonly title: string;
     readonly description?: string;
     readonly formConfig: FormConfiguration;
-    readonly validation?: StepValidationConfig;
-    readonly conditional?: StepConditionalConfig;
     readonly allowSkip?: boolean;
-    readonly requiredToComplete?: boolean;
-    readonly hooks?: StepLifecycleHooks;
-    readonly permissions?: StepPermissions;
-    readonly isDynamic?: boolean;
-    readonly dynamicConfig?: DynamicStepConfig;
     readonly renderer?: CustomStepRenderer;
+    readonly conditions?: StepConditionalBehavior;
+    readonly metadata?: Record<string, any>;
+    readonly onAfterValidation?: (stepData: Record<string, any>, helper: StepDataHelper, context: WorkflowContext) => void | Promise<void>;
 }
-interface StepValidationConfig {
-    readonly validator?: (stepData: Record<string, any>, allFormData: Record<string, any>, context: WorkflowContext) => ValidationResult | Promise<ValidationResult>;
-    readonly validateOnStepChange?: boolean;
-    readonly blockNextIfInvalid?: boolean;
-}
-interface StepConditionalConfig {
-    readonly condition: (formData: Record<string, any>, context: WorkflowContext) => boolean;
-    readonly action: 'show' | 'hide' | 'skip';
-}
-type CustomStepRenderer = (props: StepConfig) => React.ReactElement;
-interface WorkflowPersistenceData {
-    readonly workflowId: string;
-    readonly currentStepIndex: number;
-    readonly allData: Record<string, any>;
-    readonly metadata: {
-        readonly timestamp: number;
-        readonly version?: string;
-        readonly userId?: string;
-        readonly sessionId?: string;
+type CustomStepRenderer = (props: StepConfig) => React__default.ReactElement;
+interface WorkflowConfig {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly steps: StepConfig[];
+    readonly analytics?: WorkflowAnalytics;
+    readonly persistence?: {
+        adapter: any;
+        options?: any;
+        userId?: string;
     };
+    readonly plugins?: WorkflowPlugin[];
+    readonly renderConfig?: WorkflowRenderConfig;
 }
-interface PersistenceAdapter {
-    readonly name: string;
-    save(key: string, data: WorkflowPersistenceData): Promise<void>;
-    load(key: string): Promise<WorkflowPersistenceData | null>;
-    remove(key: string): Promise<void>;
-    exists(key: string): Promise<boolean>;
-    list?(pattern?: string): Promise<string[]>;
-}
-interface PersistenceConfig {
-    readonly adapter: PersistenceAdapter;
-    readonly key?: string;
-    readonly debounceMs?: number;
-    readonly autoSave?: boolean;
-    readonly saveOnStepChange?: boolean;
-    readonly encryptionKey?: string;
-    readonly maxRetries?: number;
-    readonly retryDelayMs?: number;
-    readonly onSave?: (data: WorkflowPersistenceData) => Promise<void> | void;
-    readonly onLoad?: (data: WorkflowPersistenceData) => Promise<void> | void;
-    readonly onError?: (error: Error, operation: 'save' | 'load' | 'remove') => Promise<void> | void;
-    readonly onRetry?: (attempt: number, maxRetries: number, error: Error) => Promise<void> | void;
+interface WorkflowRenderConfig {
+    readonly stepperRenderer?: WorkflowStepperRenderer;
+    readonly nextButtonRenderer?: WorkflowNextButtonRenderer;
+    readonly previousButtonRenderer?: WorkflowPreviousButtonRenderer;
+    readonly skipButtonRenderer?: WorkflowSkipButtonRenderer;
 }
 interface WorkflowAnalytics {
     readonly onWorkflowStart?: (workflowId: string, context: WorkflowContext) => void;
@@ -353,58 +943,21 @@ interface WorkflowAnalytics {
     readonly onStepStart?: (stepId: string, timestamp: number, context: WorkflowContext) => void;
     readonly onStepComplete?: (stepId: string, duration: number, data: any, context: WorkflowContext) => void;
     readonly onStepSkip?: (stepId: string, reason: string, context: WorkflowContext) => void;
-    readonly onValidationError?: (stepId: string, errors: ValidationError[], context: WorkflowContext) => void;
     readonly onError?: (error: Error, context: WorkflowContext) => void;
 }
-interface WorkflowOptimizations {
-    readonly preloadNextStep?: boolean;
-    readonly cacheValidation?: boolean;
-    readonly virtualizeSteps?: boolean;
-    readonly lazyLoadComponents?: boolean;
-    readonly maxConcurrentRequests?: number;
-}
-interface WorkflowVersion {
-    readonly version: string;
-    readonly migrationStrategy?: (oldData: any, newConfig: any) => any;
-    readonly compatibilityMode?: boolean;
-}
-interface WorkflowHooks {
-    readonly onStepChange?: (from: string, to: string, context: WorkflowContext) => void;
-    readonly onDataChange?: (data: any, context: WorkflowContext) => void;
-    readonly onValidation?: (result: ValidationResult, context: WorkflowContext) => void;
-}
 interface WorkflowPlugin {
     readonly name: string;
     readonly version?: string;
     readonly install: (workflow: any) => void;
-    readonly hooks?: WorkflowHooks;
     readonly dependencies?: string[];
 }
-interface WorkflowConfig {
-    readonly id: string;
-    readonly name: string;
-    readonly description?: string;
-    readonly steps: StepConfig[];
-    readonly branches?: ConditionalBranch[];
-    readonly navigation?: NavigationConfig;
-    readonly persistence?: PersistenceConfig;
-    readonly completion?: CompletionConfig;
-    readonly analytics?: WorkflowAnalytics;
-    readonly optimizations?: WorkflowOptimizations;
-    readonly version?: WorkflowVersion;
-    readonly plugins?: WorkflowPlugin[];
-    readonly renderConfig?: WorkflowRenderConfig;
-}
-interface NavigationConfig {
-    readonly allowBackNavigation?: boolean;
-    readonly allowStepSkipping?: boolean;
-    readonly showProgress?: boolean;
-    readonly customNavigation?: boolean;
-}
-interface CompletionConfig {
-    readonly onComplete?: (formData: Record<string, any>) => void | Promise<void>;
-    readonly confirmBeforeSubmit?: boolean;
-    readonly customCompletionStep?: any;
+interface WorkflowComponentRendererBaseProps {
+    children?: React__default.ReactNode;
+    className?: string;
+    currentStep: StepConfig;
+    stepData: Record<string, any>;
+    allData: Record<string, any>;
+    context: WorkflowContext;
 }
 interface WorkflowStepperRendererProps {
     readonly steps: StepConfig[];
@@ -413,224 +966,496 @@ interface WorkflowStepperRendererProps {
     readonly onStepClick?: (stepIndex: number) => void;
     readonly className?: string;
 }
-interface WorkflowNavigationRendererProps {
-    readonly currentStep: StepConfig;
-    readonly context: WorkflowContext;
-    readonly canGoNext: boolean;
-    readonly canGoPrevious: boolean;
-    readonly canSkip: boolean;
-    readonly isSubmitting: boolean;
-    readonly onNext: (event?: React.FormEvent) => void;
-    readonly onPrevious: (event?: React.FormEvent) => void;
-    readonly onSkip: (event?: React.FormEvent) => void;
-    readonly onSubmit: (event?: React.FormEvent) => void;
-    readonly className?: string;
+type WorkflowNextButtonRendererProps = WorkflowComponentRendererBaseProps & {
+    isLastStep: boolean;
+    canGoNext: boolean;
+    isSubmitting: boolean;
+    onSubmit: (event?: React__default.FormEvent) => void;
+};
+type WorkflowPreviousButtonRendererProps = WorkflowComponentRendererBaseProps & {
+    canGoPrevious: boolean;
+    isSubmitting: boolean;
+    onPrevious: (event?: React__default.FormEvent) => void;
+};
+type WorkflowSkipButtonRendererProps = WorkflowComponentRendererBaseProps & {
+    canSkip: boolean;
+    isSubmitting: boolean;
+    onSkip: (event?: React__default.FormEvent) => void;
+};
+type WorkflowStepperRenderer = RendererChildrenFunction<WorkflowStepperRendererProps>;
+type WorkflowNextButtonRenderer = RendererChildrenFunction<WorkflowNextButtonRendererProps>;
+type WorkflowPreviousButtonRenderer = RendererChildrenFunction<WorkflowPreviousButtonRendererProps>;
+type WorkflowSkipButtonRenderer = RendererChildrenFunction<WorkflowSkipButtonRendererProps>;
+interface PerformanceMetrics {
+    readonly timestamp: number;
+    readonly duration: number;
+    readonly memoryUsage?: number;
+    readonly renderCount?: number;
+    readonly reRenderCount?: number;
 }
-type WorkflowStepperRenderer = (props: WorkflowStepperRendererProps) => React.ReactElement;
-type WorkflowNavigationRenderer = (props: WorkflowNavigationRendererProps) => React.ReactElement;
-interface WorkflowRenderConfig {
-    readonly stepperRenderer?: WorkflowStepperRenderer;
-    readonly navigationRenderer?: WorkflowNavigationRenderer;
+interface ComponentPerformanceMetrics extends PerformanceMetrics {
+    readonly componentId: string;
+    readonly componentType: string;
+    readonly propsSize?: number;
+    readonly childrenCount?: number;
 }
-interface FormRowRendererProps {
-    row: FormFieldRow;
-    children: React.ReactNode;
-    className?: string;
-    spacing?: 'tight' | 'normal' | 'loose';
-    alignment?: 'start' | 'center' | 'end' | 'stretch';
+interface FormPerformanceMetrics extends PerformanceMetrics {
+    readonly formId: string;
+    readonly fieldCount: number;
+    readonly validationDuration: number;
+    readonly renderDuration: number;
+    readonly validationErrors: number;
 }
-interface FormBodyRendererProps {
-    formConfig: FormConfiguration;
-    children: React.ReactNode;
-    className?: string;
+interface WorkflowPerformanceMetrics extends PerformanceMetrics {
+    readonly workflowId: string;
+    readonly stepCount: number;
+    readonly currentStepIndex: number;
+    readonly navigationDuration: number;
+    readonly persistenceDuration?: number;
+    readonly conditionEvaluationDuration: number;
 }
-interface FormSubmitButtonRendererProps {
-    isSubmitting: boolean;
-    isValid: boolean;
-    isDirty: boolean;
-    onSubmit: () => void;
-    className?: string;
-    children?: React.ReactNode;
+type MonitoringEventType = 'component_render' | 'component_update' | 'form_validation' | 'form_submission' | 'workflow_navigation' | 'workflow_persistence' | 'condition_evaluation' | 'error' | 'performance_warning';
+interface MonitoringEvent {
+    readonly id: string;
+    readonly type: MonitoringEventType;
+    readonly timestamp: number;
+    readonly source: string;
+    readonly data: Record<string, any>;
+    readonly metrics?: PerformanceMetrics;
+    readonly severity?: 'low' | 'medium' | 'high' | 'critical';
 }
-type FormRowRenderer = (props: FormRowRendererProps) => React.ReactElement;
-type FormBodyRenderer = (props: FormBodyRendererProps) => React.ReactElement;
-type FormSubmitButtonRenderer = (props: FormSubmitButtonRendererProps) => React.ReactElement;
-interface FormRenderConfig {
-    readonly rowRenderer?: FormRowRenderer;
-    readonly bodyRenderer?: FormBodyRenderer;
-    readonly submitButtonRenderer?: FormSubmitButtonRenderer;
+interface ErrorMonitoringEvent extends MonitoringEvent {
+    readonly type: 'error';
+    readonly error: Error;
+    readonly stack?: string;
+    readonly context?: ValidationContext | WorkflowContext;
 }
-interface FormConfiguration {
-    readonly id: string;
-    readonly schema?: any;
-    readonly config: ril;
-    readonly rows: FormFieldRow[];
-    readonly allFields: FormFieldConfig[];
-    readonly renderConfig?: FormRenderConfig;
+interface PerformanceWarningEvent extends MonitoringEvent {
+    readonly type: 'performance_warning';
+    readonly threshold: number;
+    readonly actualValue: number;
+    readonly recommendation?: string;
+}
+interface MonitoringConfig {
+    readonly enabled: boolean;
+    readonly enablePerformanceTracking?: boolean;
+    readonly enableErrorTracking?: boolean;
+    readonly enableMemoryTracking?: boolean;
+    readonly performanceThresholds?: PerformanceThresholds;
+    readonly sampleRate?: number;
+    readonly bufferSize?: number;
+    readonly flushInterval?: number;
+    readonly onEvent?: (event: MonitoringEvent) => void;
+    readonly onBatch?: (events: MonitoringEvent[]) => void;
+    readonly onError?: (error: Error) => void;
+}
+interface PerformanceThresholds {
+    readonly componentRenderTime?: number;
+    readonly formValidationTime?: number;
+    readonly workflowNavigationTime?: number;
+    readonly memoryUsage?: number;
+    readonly reRenderCount?: number;
+}
+interface MonitoringAdapter {
+    readonly name: string;
+    readonly version?: string;
+    send: (events: MonitoringEvent[]) => Promise<void>;
+    flush?: () => Promise<void>;
+    configure?: (config: Record<string, any>) => void;
+}
+interface ConsoleMonitoringAdapter extends MonitoringAdapter {
+    readonly name: 'console';
+    readonly logLevel?: 'debug' | 'info' | 'warn' | 'error';
+}
+interface RemoteMonitoringAdapter extends MonitoringAdapter {
+    readonly name: 'remote';
+    readonly endpoint: string;
+    readonly apiKey?: string;
+    readonly headers?: Record<string, string>;
+    readonly batchSize?: number;
+    readonly retryAttempts?: number;
+}
+interface MonitoringContext {
+    readonly sessionId: string;
+    readonly userId?: string;
+    readonly userAgent?: string;
+    readonly url?: string;
+    readonly environment: 'development' | 'production' | 'test';
+    readonly version?: string;
+    readonly metadata?: Record<string, any>;
+}
+interface PerformanceProfiler {
+    start: (label: string, metadata?: Record<string, any>) => void;
+    end: (label: string) => PerformanceMetrics | null;
+    mark: (name: string) => void;
+    measure: (name: string, startMark: string, endMark?: string) => number;
+    getMetrics: (label: string) => PerformanceMetrics | null;
+    getAllMetrics: () => Record<string, PerformanceMetrics>;
+    clear: (label?: string) => void;
+}
+interface EnhancedWorkflowAnalytics extends WorkflowAnalytics {
+    readonly monitoring?: MonitoringConfig;
+    readonly onPerformanceWarning?: (event: PerformanceWarningEvent) => void;
+    readonly onMemoryLeak?: (metrics: ComponentPerformanceMetrics) => void;
 }
+interface EnhancedFormAnalytics {
+    readonly onFormRender?: (metrics: FormPerformanceMetrics) => void;
+    readonly onFormValidation?: (metrics: FormPerformanceMetrics) => void;
+    readonly onFormSubmission?: (metrics: FormPerformanceMetrics) => void;
+    readonly onFieldChange?: (fieldId: string, metrics: ComponentPerformanceMetrics) => void;
+    readonly monitoring?: MonitoringConfig;
+}
+
+declare function ComponentRendererWrapper<TProps = any>({ children, renderAs, renderer, name, props: baseProps, }: ComponentRendererWrapperProps<TProps>): React$1.ReactNode;
 
 /**
- * Create a Zod-based validator
- * @param schema - Zod schema to validate against
- * @returns Validator function
+ * Utility for merging partial configurations into existing objects
+ * Eliminates repetitive object spread operations
  */
-declare const createZodValidator: <T>(schema: z.ZodSchema<T>) => ValidatorFunction;
+declare function mergeInto<T>(target: T, partial: Partial<T>): T;
 /**
- * Create a custom validator from a validation function
- * @param validationFn - Function that returns boolean, string, or Promise
- * @returns Validator function
+ * Validates uniqueness of identifiers and throws descriptive errors
  */
-declare const createCustomValidator: (validationFn: (value: any, context: ValidationContext) => boolean | string | Promise<boolean | string>) => ValidatorFunction;
+declare function ensureUnique(ids: string[], entityName: string): void;
 /**
- * Combine multiple validators
- * @param validators - Array of validators to combine
- * @param mode - 'all' (all must pass) or 'any' (at least one must pass)
- * @returns Combined validator function
+ * Validates required fields exist in configurations
  */
-declare const combineValidators: (validators: ValidatorFunction[], mode?: "all" | "any") => ValidatorFunction;
+declare function validateRequired<T>(items: T[], requiredFields: (keyof T)[], entityName: string): void;
 /**
- * Create a conditional validator that only runs when condition is met
- * @param condition - Function to determine if validation should run
- * @param validator - Validator to run when condition is true
- * @returns Conditional validator function
+ * Auto-generates IDs when not provided
  */
-declare const createConditionalValidator: (condition: (value: any, context: ValidationContext) => boolean, validator: ValidatorFunction) => ValidatorFunction;
+declare class IdGenerator {
+    private counters;
+    next(prefix: string): string;
+    reset(prefix?: string): void;
+}
 /**
- * Common validation patterns
+ * Polymorphic helper for handling single items or arrays
  */
-declare const commonValidators: {
-    /**
-     * Required field validator
-     */
-    required: (message?: string) => ValidatorFunction;
+declare function normalizeToArray<T>(input: T | T[]): T[];
+/**
+ * Deep clone utility for configuration objects
+ */
+declare function deepClone<T>(obj: T): T;
+/**
+ * Generic configuration merger with type safety
+ */
+declare function configureObject<T>(target: T, updates: Partial<T>, allowedKeys?: (keyof T)[]): T;
+
+declare function resolveRendererChildren<TProps>(children: React.ReactNode | RendererChildrenFunction<TProps> | undefined, props: TProps): React.ReactNode;
+
+/**
+ * @fileoverview Clean validation utilities for Standard Schema
+ *
+ * This module provides utility functions for working with validation results
+ * and managing validation contexts using Standard Schema exclusively.
+ */
+
+/**
+ * Checks whether a value is considered "empty" for validation purposes.
+ *
+ * Handles: `undefined`, `null`, empty string, whitespace-only string,
+ * empty array, and empty plain object.
+ *
+ * @returns `true` if the value is empty
+ */
+declare function isEmptyValue(value: unknown): boolean;
+/**
+ * Creates a validation result object
+ *
+ * @param isValid - Whether the validation passed
+ * @param errors - Array of validation errors (empty if valid)
+ * @returns A complete ValidationResult object
+ *
+ * @example
+ * ```typescript
+ * const result = createValidationResult(false, [
+ *   { message: 'Email is required', code: 'REQUIRED' }
+ * ]);
+ * ```
+ */
+declare function createValidationResult(isValid: boolean, errors?: ValidationError[]): ValidationResult;
+/**
+ * Creates a successful validation result
+ *
+ * @returns A successful ValidationResult with no errors
+ *
+ * @example
+ * ```typescript
+ * const success = createSuccessResult();
+ * ```
+ */
+declare function createSuccessResult(): ValidationResult;
+/**
+ * Creates a failed validation result with a single error
+ *
+ * @param message - The error message
+ * @param code - Optional error code
+ * @param path - Optional field path
+ * @returns A failed ValidationResult
+ *
+ * @example
+ * ```typescript
+ * const error = createErrorResult('Email is invalid', 'INVALID_EMAIL');
+ * ```
+ */
+declare function createErrorResult(message: string, code?: string, path?: string): ValidationResult;
+/**
+ * Creates a validation context object
+ *
+ * @param options - Context configuration options
+ * @returns A complete ValidationContext object
+ *
+ * @example
+ * ```typescript
+ * const context = createValidationContext({
+ *   fieldId: 'email',
+ *   formId: 'registration',
+ *   allFormData: { email: 'test@example.com', name: 'John' }
+ * });
+ * ```
+ */
+declare function createValidationContext(options?: Partial<ValidationContext>): ValidationContext;
+
+/**
+ * Built-in validators implementing Standard Schema interface
+ * All RilayKit validators now implement Standard Schema for consistency
+ */
+
+/**
+ * Required field validator - Standard Schema implementation
+ */
+declare function required(message?: string): StandardSchemaV1<any>;
+/**
+ * Email validation - Standard Schema implementation
+ */
+declare function email(message?: string): StandardSchemaV1<string>;
+/**
+ * URL validation - Standard Schema implementation
+ */
+declare function url(message?: string): StandardSchemaV1<string>;
+/**
+ * Minimum length validation - Standard Schema implementation
+ */
+declare function minLength(min: number, message?: string): StandardSchemaV1<string>;
+/**
+ * Maximum length validation - Standard Schema implementation
+ */
+declare function maxLength(max: number, message?: string): StandardSchemaV1<string>;
+/**
+ * Pattern validation - Standard Schema implementation
+ */
+declare function pattern(regex: RegExp, message?: string): StandardSchemaV1<string>;
+/**
+ * Number validation - Standard Schema implementation
+ */
+declare function number(message?: string): StandardSchemaV1<number>;
+/**
+ * Minimum value validation - Standard Schema implementation
+ */
+declare function min(minValue: number, message?: string): StandardSchemaV1<number>;
+/**
+ * Maximum value validation - Standard Schema implementation
+ */
+declare function max(maxValue: number, message?: string): StandardSchemaV1<number>;
+/**
+ * Custom validator - Standard Schema implementation
+ */
+declare function custom<T>(fn: (value: T) => boolean, message?: string): StandardSchemaV1<T>;
+/**
+ * Async validator - Standard Schema implementation
+ */
+declare function async<T>(fn: (value: T) => Promise<boolean>, message?: string): StandardSchemaV1<T>;
+/**
+ * Utility to combine multiple Standard Schema validators
+ * This creates a new Standard Schema that runs all validations
+ */
+declare function combine<T>(...schemas: StandardSchemaV1<T>[]): StandardSchemaV1<T>;
+
+/**
+ * Unified validation utilities for Standard Schema only
+ * These replace the old validator-based system with a clean Standard Schema approach
+ */
+
+/**
+ * Checks if a value implements the Standard Schema interface
+ */
+declare function isStandardSchema(value: any): value is StandardSchema;
+/**
+ * Validates a value using a Standard Schema
+ */
+declare function validateWithStandardSchema<T extends StandardSchema>(schema: T, value: unknown): Promise<ValidationResult>;
+/**
+ * Utility to extract input type from Standard Schema at runtime (for debugging)
+ */
+declare function getSchemaInfo(schema: StandardSchema): {
+    vendor: string;
+    version: number;
+    hasTypes: boolean;
+};
+/**
+ * Type guard to check if a schema has type information
+ */
+declare function hasSchemaTypes<T extends StandardSchema>(schema: T): schema is T & {
+    '~standard': {
+        types: NonNullable<T['~standard']['types']>;
+    };
+};
+/**
+ * Validates a value using unified validation config
+ * Handles single schemas, arrays of schemas, and combines results
+ */
+declare function validateWithUnifiedConfig<T>(config: FieldValidationConfig<T>, value: T, _context: ValidationContext): Promise<ValidationResult>;
+/**
+ * Validates form data using unified validation config
+ */
+declare function validateFormWithUnifiedConfig<T extends Record<string, any>>(config: FormValidationConfig<T>, formData: T, _context: ValidationContext): Promise<ValidationResult>;
+/**
+ * Checks if a field validation config has any validation rules
+ */
+declare function hasUnifiedValidation(config: FieldValidationConfig | FormValidationConfig): boolean;
+/**
+ * Combines multiple Standard Schemas into a single schema
+ * This is useful for combining built-in validators with external schemas
+ */
+declare function combineSchemas<T>(...schemas: StandardSchemaV1<T>[]): StandardSchemaV1<T>;
+/**
+ * Utility to create a Standard Schema from any validation function
+ * This helps migrate existing validators to Standard Schema
+ */
+declare function createStandardValidator<T>(validateFn: (value: T, context?: ValidationContext) => ValidationResult | Promise<ValidationResult>, vendor?: string): StandardSchemaV1<T>;
+/**
+ * Type guard to check if value is a Standard Schema or array of Standard Schemas
+ */
+declare function isValidationRule(value: any): value is StandardSchema | StandardSchema[];
+/**
+ * Normalizes validation config to always return an array of Standard Schemas
+ */
+declare function normalizeValidationRules<T>(validate: StandardSchema<T> | StandardSchema<T>[] | undefined): StandardSchema<T>[];
+
+/**
+ * Core monitoring system for Rilay
+ * Tracks performance metrics, events, and errors across forms and workflows
+ */
+declare class RilayMonitor {
+    private config;
+    private context;
+    private adapters;
+    private eventBuffer;
+    private flushTimer?;
+    private profiler;
+    constructor(config: MonitoringConfig, context?: Partial<MonitoringContext>);
     /**
-     * Email validation
+     * Add a monitoring adapter
      */
-    email: (message?: string) => ValidatorFunction;
+    addAdapter(adapter: MonitoringAdapter): void;
     /**
-     * Minimum length validation
+     * Remove a monitoring adapter
      */
-    minLength: (min: number, message?: string) => ValidatorFunction;
+    removeAdapter(adapterName: string): void;
     /**
-     * Maximum length validation
+     * Track a monitoring event
      */
-    maxLength: (max: number, message?: string) => ValidatorFunction;
+    track(type: MonitoringEventType, source: string, data: Record<string, any>, metrics?: PerformanceMetrics, severity?: 'low' | 'medium' | 'high' | 'critical'): void;
     /**
-     * Pattern/regex validation
+     * Track an error
      */
-    pattern: (regex: RegExp, message?: string) => ValidatorFunction;
+    trackError(error: Error, source: string, context?: any): void;
     /**
-     * Number range validation
+     * Get the performance profiler
      */
-    numberRange: (min?: number, max?: number, message?: string) => ValidatorFunction;
+    getProfiler(): PerformanceProfiler;
     /**
-     * URL validation
+     * Update monitoring context
      */
-    url: (message?: string) => ValidatorFunction;
+    updateContext(updates: Partial<MonitoringContext>): void;
     /**
-     * Phone number validation (basic)
+     * Flush all buffered events
      */
-    phoneNumber: (message?: string) => ValidatorFunction;
+    flush(): Promise<void>;
     /**
-     * Custom async validation with debouncing
+     * Destroy the monitor and clean up resources
      */
-    asyncValidation: (asyncFn: (value: any, context: ValidationContext) => Promise<boolean | string>, debounceMs?: number) => ValidatorFunction;
-};
+    destroy(): Promise<void>;
+    private startFlushTimer;
+    private checkPerformanceThresholds;
+    private createPerformanceWarning;
+}
+/**
+ * Initialize global monitoring
+ */
+declare function initializeMonitoring(config: MonitoringConfig, context?: Partial<MonitoringContext>): RilayMonitor;
 /**
- * Utility to create validation result
- * @param isValid - Whether validation passed
- * @param errors - Array of errors (optional)
- * @param warnings - Array of warnings (optional)
- * @returns ValidationResult object
+ * Get the global monitor instance
  */
-declare const createValidationResult: (isValid: boolean, errors?: ValidationError[], warnings?: ValidationError[]) => ValidationResult;
+declare function getGlobalMonitor(): RilayMonitor | null;
 /**
- * Utility to create validation error
- * @param code - Error code
- * @param message - Error message
- * @param path - Error path (optional)
- * @returns ValidationError object
+ * Destroy global monitoring
  */
-declare const createValidationError: (code: string, message: string, path?: string[]) => ValidationError;
+declare function destroyGlobalMonitoring(): Promise<void>;
 
 /**
- * LocalStorage persistence adapter
- * Perfect for client-side persistence across browser sessions
+ * Console monitoring adapter
+ * Logs events to the browser console
  */
-declare class LocalStorageAdapter implements PersistenceAdapter {
-    readonly name = "localStorage";
-    save(key: string, data: WorkflowPersistenceData): Promise<void>;
-    load(key: string): Promise<WorkflowPersistenceData | null>;
-    remove(key: string): Promise<void>;
-    exists(key: string): Promise<boolean>;
-    list(pattern?: string): Promise<string[]>;
-}
-/**
- * SessionStorage persistence adapter
- * Perfect for temporary persistence within a single browser session
- */
-declare class SessionStorageAdapter implements PersistenceAdapter {
-    readonly name = "sessionStorage";
-    save(key: string, data: WorkflowPersistenceData): Promise<void>;
-    load(key: string): Promise<WorkflowPersistenceData | null>;
-    remove(key: string): Promise<void>;
-    exists(key: string): Promise<boolean>;
-    list(pattern?: string): Promise<string[]>;
-}
-/**
- * In-Memory persistence adapter
- * Perfect for testing or temporary workflows
- */
-declare class MemoryAdapter implements PersistenceAdapter {
-    readonly name = "memory";
-    private storage;
-    save(key: string, data: WorkflowPersistenceData): Promise<void>;
-    load(key: string): Promise<WorkflowPersistenceData | null>;
-    remove(key: string): Promise<void>;
-    exists(key: string): Promise<boolean>;
-    list(pattern?: string): Promise<string[]>;
-    clear(): void;
+declare class ConsoleAdapter implements ConsoleMonitoringAdapter {
+    readonly name = "console";
+    readonly logLevel: 'debug' | 'info' | 'warn' | 'error';
+    constructor(logLevel?: 'debug' | 'info' | 'warn' | 'error');
+    send(events: MonitoringEvent[]): Promise<void>;
+    private logEvent;
+    private shouldLog;
 }
 /**
- * Composite adapter that can use multiple adapters with fallback
- * Perfect for robust persistence with primary/backup strategies
+ * Remote monitoring adapter
+ * Sends events to a remote endpoint
  */
-declare class CompositeAdapter implements PersistenceAdapter {
-    private primary;
-    private fallbacks;
-    readonly name = "composite";
-    constructor(primary: PersistenceAdapter, fallbacks?: PersistenceAdapter[]);
-    save(key: string, data: WorkflowPersistenceData): Promise<void>;
-    load(key: string): Promise<WorkflowPersistenceData | null>;
-    remove(key: string): Promise<void>;
-    exists(key: string): Promise<boolean>;
-    list(pattern?: string): Promise<string[]>;
+declare class RemoteAdapter implements RemoteMonitoringAdapter {
+    readonly name = "remote";
+    readonly endpoint: string;
+    readonly apiKey?: string;
+    readonly headers: Record<string, string>;
+    readonly batchSize: number;
+    readonly retryAttempts: number;
+    private eventQueue;
+    private isProcessing;
+    constructor(config: {
+        endpoint: string;
+        apiKey?: string;
+        headers?: Record<string, string>;
+        batchSize?: number;
+        retryAttempts?: number;
+    });
+    send(events: MonitoringEvent[]): Promise<void>;
+    flush(): Promise<void>;
+    configure(config: Record<string, any>): void;
+    private processQueue;
+    private sendBatch;
+    private delay;
 }
-
 /**
- * Utility functions to create persistence configurations easily
+ * Local storage adapter for offline support
  */
-declare const persistence: {
-    /**
-     * Create a localStorage-based persistence configuration
-     */
-    localStorage(options?: Partial<PersistenceConfig>): PersistenceConfig;
-    /**
-     * Create a sessionStorage-based persistence configuration
-     */
-    sessionStorage(options?: Partial<PersistenceConfig>): PersistenceConfig;
-    /**
-     * Create an in-memory persistence configuration (for testing)
-     */
-    memory(options?: Partial<PersistenceConfig>): PersistenceConfig;
-    /**
-     * Create a custom persistence configuration
-     */
-    custom(adapter: PersistenceAdapter, options?: Partial<PersistenceConfig>): PersistenceConfig;
-};
+declare class LocalStorageAdapter implements MonitoringAdapter {
+    readonly name = "localStorage";
+    private readonly storageKey;
+    private readonly maxEvents;
+    constructor(maxEvents?: number);
+    send(events: MonitoringEvent[]): Promise<void>;
+    flush(): Promise<void>;
+    getStoredEvents(): MonitoringEvent[];
+    clearStoredEvents(): void;
+    getEventCount(): number;
+}
 /**
- * Utility to create persistence configurations with retry logic
+ * Development adapter that provides detailed logging
  */
-declare function createResilientPersistence(primary: PersistenceAdapter, fallback?: PersistenceAdapter, options?: Partial<PersistenceConfig>): PersistenceConfig;
+declare class DevelopmentAdapter implements MonitoringAdapter {
+    readonly name = "development";
+    private readonly console;
+    send(events: MonitoringEvent[]): Promise<void>;
+    private logPerformanceSummary;
+    private logErrorSummary;
+}
 
-export { type CompletionConfig, type ComponentConfig, type ComponentOptions, type ComponentRenderProps, type ComponentRenderer, type ComponentType, CompositeAdapter, type ConditionalBranch, type ConditionalConfig, type CustomStepRenderer, type DynamicStepConfig, type FormBodyRenderer, type FormBodyRendererProps, type FormConfiguration, type FormFieldConfig, type FormFieldRow, type FormRenderConfig, type FormRowRenderer, type FormRowRendererProps, type FormSubmitButtonRenderer, type FormSubmitButtonRendererProps, type InputType, type LayoutType, LocalStorageAdapter, MemoryAdapter, type NavigationConfig, type PersistenceAdapter, type PersistenceConfig, type RetryPolicy, type RilayLicenseConfig, SessionStorageAdapter, type StepConditionalConfig, type StepConfig, type StepLifecycleHooks, type StepPermissions, type StepValidationConfig, type ValidationConfig, type ValidationContext, type ValidationError, type ValidationResult, type ValidationWarning, type ValidatorFunction, type WorkflowAnalytics, type WorkflowConfig, type WorkflowContext, type WorkflowHooks, type WorkflowNavigationRenderer, type WorkflowNavigationRendererProps, type WorkflowOptimizations, type WorkflowPersistenceData, type WorkflowPlugin, type WorkflowRenderConfig, type WorkflowStepperRenderer, type WorkflowStepperRendererProps, type WorkflowVersion, combineValidators, commonValidators, createConditionalValidator, createCustomValidator, createResilientPersistence, createValidationError, createValidationResult, createZodValidator, persistence, ril };
+export { type ComponentBuilderMetadata, type ComponentConfig, type ComponentPerformanceMetrics, type ComponentRenderProps, type ComponentRenderPropsV2, type ComponentRenderer, type ComponentRendererBaseProps, ComponentRendererWrapper, type ComponentRendererWrapperProps, type ConditionBuilder as Condition, type ConditionBuilder, type ConditionConfig, ConditionDependencyGraph, type ConditionEvaluator, type ConditionOperator, type ConditionValue, type ConditionalBehavior, ConsoleAdapter, type ConsoleMonitoringAdapter, type CustomStepRenderer, DevelopmentAdapter, type EnhancedFormAnalytics, type EnhancedWorkflowAnalytics, type ErrorMonitoringEvent, type FieldActions, type FieldConditions, type FieldContext, type FieldRenderer, type FieldRendererProps, type FieldRendererPropsV2, type FieldSchemaDefinition, type FieldState, type FieldValidationConfig, type FieldValidator, type FormActions, type FormBodyRenderer, type FormBodyRendererProps, type FormComponentRendererProps, type FormConfiguration, type FormContextValue, type FormFieldConfig, type FormFieldRow, type FormPerformanceMetrics, type FormRenderConfig, type FormRepeatableRow, type FormRowEntry, type FormRowRenderer, type FormRowRendererProps, type FormState, type FormSubmitButtonRenderer, type FormSubmitButtonRendererProps, type FormSubmitButtonRendererPropsV2, type FormValidationConfig, type FormValidator, IdGenerator, type InferInput, type InferOutput, LocalStorageAdapter, type LogicalOperator, type MonitoringAdapter, type MonitoringConfig, type MonitoringContext, type MonitoringEvent, type MonitoringEventType, type PerformanceMetrics, type PerformanceProfiler, type PerformanceThresholds, type PerformanceWarningEvent, type PropertyEditorDefinition, type PropertyEditorProps, RemoteAdapter, type RemoteMonitoringAdapter, type RendererChildrenFunction, type RepeatableFieldConfig, type RepeatableFieldItem, type RepeatableFieldRenderer, type RepeatableFieldRendererProps, type RepeatableItemRenderer, type RepeatableItemRendererProps, type RilayInstance, type RilayLicenseConfig, RilayMonitor, type StandardSchema, type StepConditionalBehavior, type StepConfig, type StepDataHelper, type ValidationContext, type ValidationError, type ValidationResult, type ValidationState, type WorkflowAnalytics, type WorkflowButtonRendererPropsV2, type WorkflowComponentRendererBaseProps, type WorkflowConfig, type WorkflowContext, type WorkflowNavigationState, type WorkflowNextButtonRenderer, type WorkflowNextButtonRendererProps, type WorkflowPerformanceMetrics, type WorkflowPlugin, type WorkflowPreviousButtonRenderer, type WorkflowPreviousButtonRendererProps, type WorkflowProgressState, type WorkflowRenderConfig, type WorkflowSkipButtonRenderer, type WorkflowSkipButtonRendererProps, type WorkflowStepContext, type WorkflowStepState, type WorkflowStepperRenderer, type WorkflowStepperRendererProps, async, combine, combineSchemas, configureObject, createErrorResult, createStandardValidator, createSuccessResult, createValidationContext, createValidationResult, custom, deepClone, destroyGlobalMonitoring, email, ensureUnique, evaluateCondition, extractAllDependencies, extractConditionDependencies, getGlobalMonitor, getSchemaInfo, hasSchemaTypes, hasUnifiedValidation, initializeMonitoring, isEmptyValue, isStandardSchema, isValidationRule, max, maxLength, mergeInto, min, minLength, normalizeToArray, normalizeValidationRules, number, pattern, required, resolveRendererChildren, ril, url, validateFormWithUnifiedConfig, validateRequired, validateWithStandardSchema, validateWithUnifiedConfig, when };