@rilaykit/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1399 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import * as React$1 from 'react';
+import React__default from 'react';
+
+/**
+ * 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 ConditionDependencyGraph {
+    /**
+     * Maps field IDs to their dependencies (fields they depend on)
+     * fieldId -> Set of field paths it depends on
+     */
+    private readonly fieldDependencies;
+    /**
+     * 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
+     */
+    private readonly reverseDependencies;
+    /**
+     * 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)
+     */
+    addField(fieldId: string, conditions?: ConditionalBehavior): void;
+    /**
+     * Removes a field from the graph.
+     *
+     * @param fieldId - The ID of the field to remove
+     */
+    removeField(fieldId: string): void;
+    /**
+     * 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
+     */
+    getAffectedFields(changedPath: string): string[];
+    /**
+     * 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
+     */
+    getAffectedFieldsMultiple(changedPaths: string[]): string[];
+    /**
+     * Gets the dependencies for a specific field.
+     *
+     * @param fieldId - The ID of the field
+     * @returns Array of field paths this field depends on
+     */
+    getDependencies(fieldId: string): string[];
+    /**
+     * Checks if a field has any dependencies.
+     *
+     * @param fieldId - The ID of the field
+     * @returns True if the field has conditional dependencies
+     */
+    hasDependencies(fieldId: string): boolean;
+    /**
+     * Gets all fields in the graph.
+     *
+     * @returns Array of all field IDs
+     */
+    getAllFields(): string[];
+    /**
+     * Gets all unique dependency paths in the graph.
+     *
+     * @returns Array of all field paths that are dependencies
+     */
+    getAllDependencyPaths(): string[];
+    /**
+     * Clears the entire graph.
+     */
+    clear(): void;
+    /**
+     * Gets the size of the graph (number of fields).
+     */
+    get size(): number;
+    /**
+     * Creates a debug representation of the graph.
+     * Useful for development and testing.
+     */
+    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;
+            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;
+    /**
+     * Static factory method to create a new ril instance
+     */
+    static create<CT>(): ril<CT>;
+    /**
+     * 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,
+     *     }
+     *   });
+     * ```
+     */
+    addComponent<NewType extends string, TProps = any>(type: NewType, config: Omit<ComponentConfig<TProps>, 'id' | 'type'>): ril<C & {
+        [K in NewType]: TProps;
+    }>;
+    /**
+     * 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'
+     *       }
+     *     }
+     *   });
+     * ```
+     */
+    configure(config: Partial<FormRenderConfig & WorkflowRenderConfig>): ril<C>;
+    /**
+     * Configuration getters
+     */
+    getFormRenderConfig(): FormRenderConfig;
+    getWorkflowRenderConfig(): WorkflowRenderConfig;
+    /**
+     * Component management methods
+     */
+    getComponent<T extends keyof C & string>(id: T): ComponentConfig<C[T]> | undefined;
+    getAllComponents(): ComponentConfig[];
+    hasComponent(id: string): boolean;
+    /**
+     * 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
+     */
+    removeComponent(id: string): ril<C>;
+    /**
+     * Clear all components from the configuration (immutable)
+     * Returns a new instance with no components
+     *
+     * @returns A new empty ril instance
+     */
+    clear(): ril<C>;
+    /**
+     * Create a deep copy of the current ril instance
+     */
+    clone(): ril<C>;
+    /**
+     * Enhanced statistics with more detailed information
+     */
+    getStats(): {
+        total: number;
+        byType: Record<string, number>;
+        hasCustomRenderers: {
+            row: boolean;
+            body: boolean;
+            submitButton: boolean;
+            field: boolean;
+            stepper: boolean;
+            workflowNextButton: boolean;
+            workflowPreviousButton: boolean;
+            workflowSkipButton: boolean;
+        };
+    };
+    /**
+     * 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 {
+    readonly licenseKey?: string;
+    readonly environment?: 'development' | 'production';
+    readonly allowTrial?: boolean;
+}
+interface ValidationError {
+    readonly message: string;
+    readonly code?: string;
+    readonly path?: string;
+}
+interface ValidationResult {
+    readonly isValid: boolean;
+    readonly errors: ValidationError[];
+    readonly value?: any;
+}
+interface ValidationContext {
+    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>;
+}
+/** @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 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>;
+}
+interface ComponentRenderProps<TProps = any> {
+    id: string;
+    props: TProps;
+    value?: any;
+    onChange?: (value: any) => void;
+    onBlur?: () => void;
+    disabled?: boolean;
+    error?: ValidationError[];
+    isValidating?: boolean;
+    [key: string]: any;
+}
+/**
+ * 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;
+        value: any;
+        [key: string]: any;
+    }>;
+    /** 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: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly renderer: ComponentRenderer<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?: FieldValidationConfig;
+    readonly conditions?: ConditionalBehavior;
+}
+interface FormFieldRow {
+    readonly id: string;
+    readonly fields: FormFieldConfig[];
+    readonly maxColumns?: number;
+}
+interface FormConfiguration<C extends Record<string, any> = Record<string, never>> {
+    readonly id: string;
+    readonly config: ril<C>;
+    readonly rows: FormFieldRow[];
+    readonly allFields: FormFieldConfig[];
+    readonly renderConfig?: FormRenderConfig;
+    readonly validation?: FormValidationConfig;
+}
+interface FormRenderConfig {
+    readonly rowRenderer?: FormRowRenderer;
+    readonly bodyRenderer?: FormBodyRenderer;
+    readonly submitButtonRenderer?: FormSubmitButtonRenderer;
+    readonly fieldRenderer?: FieldRenderer;
+}
+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;
+    readonly totalSteps: number;
+    readonly allData: Record<string, any>;
+    readonly stepData: Record<string, any>;
+    readonly isFirstStep: boolean;
+    readonly isLastStep: boolean;
+    readonly visitedSteps: Set<string>;
+    readonly visibleVisitedSteps: Set<string>;
+    readonly passedSteps: Set<string>;
+}
+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 allowSkip?: boolean;
+    readonly renderer?: CustomStepRenderer;
+    readonly conditions?: StepConditionalBehavior;
+    readonly metadata?: Record<string, any>;
+    readonly onAfterValidation?: (stepData: Record<string, any>, helper: StepDataHelper, context: WorkflowContext) => void | Promise<void>;
+}
+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 WorkflowRenderConfig {
+    readonly stepperRenderer?: WorkflowStepperRenderer;
+    readonly nextButtonRenderer?: WorkflowNextButtonRenderer;
+    readonly previousButtonRenderer?: WorkflowPreviousButtonRenderer;
+    readonly skipButtonRenderer?: WorkflowSkipButtonRenderer;
+}
+interface WorkflowAnalytics {
+    readonly onWorkflowStart?: (workflowId: string, context: WorkflowContext) => void;
+    readonly onWorkflowComplete?: (workflowId: string, duration: number, data: any) => void;
+    readonly onWorkflowAbandon?: (workflowId: string, currentStep: string, data: any) => void;
+    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 onError?: (error: Error, context: WorkflowContext) => void;
+}
+interface WorkflowPlugin {
+    readonly name: string;
+    readonly version?: string;
+    readonly install: (workflow: any) => void;
+    readonly dependencies?: string[];
+}
+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[];
+    readonly currentStepIndex: number;
+    readonly visitedSteps: Set<string>;
+    readonly onStepClick?: (stepIndex: number) => 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;
+}
+interface ComponentPerformanceMetrics extends PerformanceMetrics {
+    readonly componentId: string;
+    readonly componentType: string;
+    readonly propsSize?: number;
+    readonly childrenCount?: number;
+}
+interface FormPerformanceMetrics extends PerformanceMetrics {
+    readonly formId: string;
+    readonly fieldCount: number;
+    readonly validationDuration: number;
+    readonly renderDuration: number;
+    readonly validationErrors: number;
+}
+interface WorkflowPerformanceMetrics extends PerformanceMetrics {
+    readonly workflowId: string;
+    readonly stepCount: number;
+    readonly currentStepIndex: number;
+    readonly navigationDuration: number;
+    readonly persistenceDuration?: number;
+    readonly conditionEvaluationDuration: number;
+}
+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';
+}
+interface ErrorMonitoringEvent extends MonitoringEvent {
+    readonly type: 'error';
+    readonly error: Error;
+    readonly stack?: string;
+    readonly context?: ValidationContext | WorkflowContext;
+}
+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;
+
+/**
+ * Utility for merging partial configurations into existing objects
+ * Eliminates repetitive object spread operations
+ */
+declare function mergeInto<T>(target: T, partial: Partial<T>): T;
+/**
+ * Validates uniqueness of identifiers and throws descriptive errors
+ */
+declare function ensureUnique(ids: string[], entityName: string): void;
+/**
+ * Validates required fields exist in configurations
+ */
+declare function validateRequired<T>(items: T[], requiredFields: (keyof T)[], entityName: string): void;
+/**
+ * Auto-generates IDs when not provided
+ */
+declare class IdGenerator {
+    private counters;
+    next(prefix: string): string;
+    reset(prefix?: string): void;
+}
+/**
+ * Polymorphic helper for handling single items or arrays
+ */
+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.
+ */
+
+/**
+ * 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>);
+    /**
+     * Add a monitoring adapter
+     */
+    addAdapter(adapter: MonitoringAdapter): void;
+    /**
+     * Remove a monitoring adapter
+     */
+    removeAdapter(adapterName: string): void;
+    /**
+     * Track a monitoring event
+     */
+    track(type: MonitoringEventType, source: string, data: Record<string, any>, metrics?: PerformanceMetrics, severity?: 'low' | 'medium' | 'high' | 'critical'): void;
+    /**
+     * Track an error
+     */
+    trackError(error: Error, source: string, context?: any): void;
+    /**
+     * Get the performance profiler
+     */
+    getProfiler(): PerformanceProfiler;
+    /**
+     * Update monitoring context
+     */
+    updateContext(updates: Partial<MonitoringContext>): void;
+    /**
+     * Flush all buffered events
+     */
+    flush(): Promise<void>;
+    /**
+     * Destroy the monitor and clean up resources
+     */
+    destroy(): Promise<void>;
+    private startFlushTimer;
+    private checkPerformanceThresholds;
+    private createPerformanceWarning;
+}
+/**
+ * Initialize global monitoring
+ */
+declare function initializeMonitoring(config: MonitoringConfig, context?: Partial<MonitoringContext>): RilayMonitor;
+/**
+ * Get the global monitor instance
+ */
+declare function getGlobalMonitor(): RilayMonitor | null;
+/**
+ * Destroy global monitoring
+ */
+declare function destroyGlobalMonitoring(): Promise<void>;
+
+/**
+ * Console monitoring adapter
+ * Logs events to the browser console
+ */
+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;
+}
+/**
+ * Remote monitoring adapter
+ * Sends events to a remote endpoint
+ */
+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;
+}
+/**
+ * Local storage adapter for offline support
+ */
+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;
+}
+/**
+ * Development adapter that provides detailed logging
+ */
+declare class DevelopmentAdapter implements MonitoringAdapter {
+    readonly name = "development";
+    private readonly console;
+    send(events: MonitoringEvent[]): Promise<void>;
+    private logPerformanceSummary;
+    private logErrorSummary;
+}
+
+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 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 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, isStandardSchema, isValidationRule, max, maxLength, mergeInto, min, minLength, normalizeToArray, normalizeValidationRules, number, pattern, required, resolveRendererChildren, ril, url, validateFormWithUnifiedConfig, validateRequired, validateWithStandardSchema, validateWithUnifiedConfig, when };