extended-dynamic-forms 0.1.21 → 0.1.22

package/dist/ExtendedForm.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ExtendedFormProps } from './types';
+
+export declare const ExtendedForm: React.ForwardRefExoticComponent<Omit<ExtendedFormProps, "ref"> & React.RefAttributes<any>>;

package/dist/WizardForm.d.ts

@@ -0,0 +1,26 @@
+import { WebhookConfig } from './types';
+
+export interface WizardStep {
+    id: string;
+    title: string;
+    description?: string;
+}
+export interface WizardFormProps {
+    schema: any;
+    uiSchema: any;
+    conditions?: any[];
+    webhooks?: WebhookConfig[];
+    formData?: any;
+    onSubmit?: (data: any) => void;
+    onStepChange?: (step: number, data: any) => void;
+    onFieldFocus?: (event: any) => void;
+    onFieldBlur?: (event: any) => void;
+    onFieldChange?: (event: any) => void;
+    showProgressBar?: boolean;
+    showStepDescription?: boolean;
+    submitButtonText?: string;
+    liveValidate?: boolean;
+    showErrorList?: boolean;
+}
+export declare function WizardForm({ schema, uiSchema, conditions, // JSON Rules Engine format conditions
+webhooks, formData: initialFormData, onSubmit, onStepChange, onFieldFocus, onFieldBlur, onFieldChange, showProgressBar, showStepDescription, submitButtonText, liveValidate, showErrorList, }: WizardFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/arrays/ArrayFieldItemTemplate.d.ts

@@ -0,0 +1,3 @@
+import { ArrayFieldItemTemplateType } from '@rjsf/utils';
+
+export declare const ArrayFieldItemTemplate: (props: ArrayFieldItemTemplateType) => import("react/jsx-runtime").JSX.Element;

package/dist/components/arrays/ArrayFieldTemplate.d.ts

@@ -0,0 +1,3 @@
+import { ArrayFieldTemplateProps } from '@rjsf/utils';
+
+export declare const ArrayFieldTemplate: (props: ArrayFieldTemplateProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/arrays/index.d.ts

@@ -0,0 +1,2 @@
+export { ArrayFieldTemplate } from './ArrayFieldTemplate';
+export { ArrayFieldItemTemplate } from './ArrayFieldItemTemplate';

package/dist/components/fields/AddressField.d.ts

@@ -0,0 +1,3 @@
+import { FieldProps } from '@rjsf/utils';
+
+export declare const AddressField: React.FC<FieldProps>;

package/dist/components/fields/CurrencyField.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { FieldProps } from '@rjsf/utils';
+
+export declare const CurrencyField: React.FC<FieldProps>;

package/dist/components/fields/PhoneField.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { FieldProps } from '@rjsf/utils';
+
+export declare const PhoneField: React.FC<FieldProps>;

package/dist/components/index.d.ts

@@ -0,0 +1,24 @@
+import { AddressField } from './fields/AddressField';
+import { PhoneField } from './fields/PhoneField';
+import { CurrencyField } from './fields/CurrencyField';
+import { ArrayFieldTemplate, ArrayFieldItemTemplate } from './arrays';
+import { WizardObjectFieldTemplate, WizardSectionTemplate } from '../layouts/wizard';
+import { SubmitButton } from './templates/SubmitButton';
+import { FieldTemplate } from './templates/FieldTemplate';
+
+export declare const customFields: {
+    address: import('react').FC<import('@rjsf/utils').FieldProps<any, import('@rjsf/utils').RJSFSchema, any>>;
+    phone: import('react').FC<import('@rjsf/utils').FieldProps<any, import('@rjsf/utils').RJSFSchema, any>>;
+    currency: import('react').FC<import('@rjsf/utils').FieldProps<any, import('@rjsf/utils').RJSFSchema, any>>;
+};
+export declare const customTemplates: {
+    FieldTemplate: import('react').FC<import('@rjsf/utils').FieldTemplateProps>;
+    ArrayFieldTemplate: (props: import('@rjsf/utils').ArrayFieldTemplateProps) => import("react/jsx-runtime").JSX.Element;
+    ArrayFieldItemTemplate: (props: import('@rjsf/utils').ArrayFieldItemTemplateType) => import("react/jsx-runtime").JSX.Element;
+    WizardObjectFieldTemplate: import('react').FC<import('@rjsf/utils').ObjectFieldTemplateProps>;
+    WizardSectionTemplate: import('react').FC<import('../layouts/wizard/WizardSectionTemplate').WizardSectionTemplateProps>;
+    ButtonTemplates: {
+        SubmitButton: import('react').FC<import('@rjsf/utils').SubmitButtonProps>;
+    };
+};
+export { AddressField, PhoneField, CurrencyField, FieldTemplate, ArrayFieldTemplate, ArrayFieldItemTemplate, WizardObjectFieldTemplate, WizardSectionTemplate, SubmitButton, };

package/dist/components/templates/FieldTemplate.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { FieldTemplateProps } from '@rjsf/utils';
+
+export declare const FieldTemplate: React.FC<FieldTemplateProps>;

package/dist/components/templates/SubmitButton.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { SubmitButtonProps } from '@rjsf/utils';
+
+export declare const SubmitButton: React.FC<SubmitButtonProps>;

package/dist/components/templates/index.d.ts

@@ -0,0 +1,2 @@
+export { FieldTemplate } from './FieldTemplate';
+export { SubmitButton } from './SubmitButton';

package/dist/conditionals/ConditionalActions.d.ts

@@ -0,0 +1,13 @@
+import { ConditionalAction, ConditionalActions } from '../types';
+
+declare const remove: ConditionalAction;
+declare const require: ConditionalAction;
+declare const uiAppend: ConditionalAction;
+declare const uiOverride: ConditionalAction;
+declare const uiReplace: ConditionalAction;
+declare const enable: ConditionalAction;
+declare const disable: ConditionalAction;
+declare const optional: ConditionalAction;
+declare const show: ConditionalAction;
+export declare const defaultActions: ConditionalActions;
+export { remove, require, uiAppend, uiOverride, uiReplace, enable, disable, optional, show, };

package/dist/conditionals/ConditionalContext.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+import { RJSFSchema, UiSchema } from '@rjsf/utils';
+import { ConditionalRule, ConditionalConfig, ConditionalState } from '../types';
+import { DynamicArrayConditionalEngine } from './DynamicArrayConditionalEngine';
+
+interface ConditionalContextType {
+    state: ConditionalState;
+    processor: DynamicArrayConditionalEngine | null;
+    processConditionals: (formData: any) => Promise<void>;
+    updateRules: (rules: ConditionalRule[]) => void;
+    addAction: (actionType: string, actionFunction: any) => void;
+    removeAction: (actionType: string) => void;
+    getAvailableActions: () => string[];
+}
+export interface ConditionalProviderProps {
+    children: React.ReactNode;
+    schema: RJSFSchema;
+    uiSchema?: UiSchema;
+    config?: ConditionalConfig;
+    onSchemaChange?: (schemas: {
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+    }) => void;
+}
+export declare const ConditionalProvider: React.FC<ConditionalProviderProps>;
+export declare const useConditionals: () => ConditionalContextType;
+export declare const useConditionalSchema: () => {
+    schema: RJSFSchema;
+    uiSchema: UiSchema;
+    isProcessing: boolean;
+};
+export {};

package/dist/conditionals/DynamicArrayConditionalEngine.d.ts

@@ -0,0 +1,77 @@
+import { RJSFSchema, UiSchema } from '@rjsf/utils';
+import { ConditionalRule, ConditionalEvent, ConditionalActions, ConditionalEngineInstance } from '../types';
+
+export declare class DynamicArrayConditionalEngine implements ConditionalEngineInstance {
+    private originalRules;
+    private engine;
+    private expandedRules;
+    constructor(rules: ConditionalRule[], schema: RJSFSchema, uiSchema?: UiSchema, extraActions?: ConditionalActions);
+    /**
+     * Expand array patterns like directors[*] based on actual form data
+     */
+    expandArrayPatterns(rules: ConditionalRule[], formData: any): ConditionalRule[];
+    /**
+     * Check if a rule contains array patterns like [*]
+     */
+    private hasArrayPatterns;
+    /**
+     * Expand a single rule that contains array patterns
+     */
+    private expandSingleRule;
+    /**
+     * Find all array patterns like "directors[*]" in a rule
+     */
+    private findArrayPatterns;
+    /**
+     * Expand a rule for a specific array index
+     */
+    private expandRuleForIndex;
+    /**
+     * Get nested value from object using dot notation
+     */
+    private getNestedValue;
+    /**
+     * Pre-process uiSchema to ensure array items have proper template structure
+     */
+    private preprocessUiSchemaForArrays;
+    /**
+     * Main processing method - implement ConditionalEngineInstance interface
+     */
+    processFormData(formData: any): Promise<{
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+        formData: any;
+    }>;
+    /**
+     * Get the original unexpanded rules
+     */
+    getOriginalRules(): ConditionalRule[];
+    /**
+     * Get the current expanded rules
+     */
+    getCurrentRules(): ConditionalRule[];
+    /**
+     * Manually set rules (useful for testing)
+     */
+    setRules(rules: ConditionalRule[]): void;
+    /**
+     * Add a rule to the engine (implement ConditionalEngineInstance interface)
+     */
+    addRule(rule: ConditionalRule): void;
+    /**
+     * Run the conditional engine and return events (implement ConditionalEngineInstance interface)
+     */
+    run(formData: any): Promise<ConditionalEvent[]>;
+    /**
+     * Add an action to the engine (for ConditionalContext compatibility)
+     */
+    addAction(actionType: string, actionFunction: any): void;
+    /**
+     * Remove an action from the engine (for ConditionalContext compatibility)
+     */
+    removeAction(actionType: string): void;
+    /**
+     * Get available actions (for ConditionalContext compatibility)
+     */
+    getAvailableActions(): string[];
+}

package/dist/conditionals/SimpleConditionalEngine.d.ts

@@ -0,0 +1,41 @@
+import { RJSFSchema, UiSchema } from '@rjsf/utils';
+import { ConditionalRule, ConditionalEvent, ConditionalActions, ConditionalEngineInstance } from '../types';
+
+export declare class SimpleConditionalEngine implements ConditionalEngineInstance {
+    private rules;
+    private actions;
+    private originalSchema;
+    private originalUiSchema;
+    constructor(rules: ConditionalRule[], schema: RJSFSchema, uiSchema?: UiSchema, extraActions?: ConditionalActions);
+    /**
+     * Get nested value from object using dot notation with array index support
+     */
+    private getNestedValue;
+    /**
+     * Evaluate a single condition against form data
+     */
+    private evaluateCondition;
+    /**
+     * Evaluate field-level condition
+     */
+    private evaluateFieldCondition;
+    addRule(rule: ConditionalRule): void;
+    run(formData: any): Promise<ConditionalEvent[]>;
+    processEvents(events: ConditionalEvent[], schema: RJSFSchema, uiSchema: UiSchema, formData: any): {
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+    };
+    processFormData(formData: any): Promise<{
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+        formData: any;
+    }>;
+    runAndProcess(formData: any, schema: RJSFSchema, uiSchema: UiSchema): Promise<{
+        schema: RJSFSchema;
+        uiSchema: UiSchema;
+        events: ConditionalEvent[];
+    }>;
+    getAvailableActions(): string[];
+    addAction(actionType: string, actionFunction: any): void;
+    removeAction(actionType: string): void;
+}

package/dist/conditionals/SmartJsonRulesTransformer.d.ts

@@ -0,0 +1,10 @@
+import { ConditionalRule } from '../types';
+
+/**
+ * Smart transformation of JSON Rules Engine rules to internal format
+ *
+ * Handles show/hide pairs intelligently by converting them to single remove rules
+ * Also handles rules that are already in internal format
+ */
+export declare function smartTransformJsonRulesEngine(rules: any[]): ConditionalRule[];
+export { smartTransformJsonRulesEngine as transformJsonRulesEngine };

package/dist/conditionals/index.d.ts

@@ -0,0 +1,7 @@
+export { SimpleConditionalEngine as ConditionalProcessor } from './SimpleConditionalEngine';
+export { SimpleConditionalEngine } from './SimpleConditionalEngine';
+export { DynamicArrayConditionalEngine } from './DynamicArrayConditionalEngine';
+export { defaultActions, remove, require, uiAppend, uiOverride, uiReplace, enable, disable, optional, show, } from './ConditionalActions';
+export { smartTransformJsonRulesEngine as transformJsonRulesEngine } from './SmartJsonRulesTransformer';
+export { smartTransformJsonRulesEngine } from './SmartJsonRulesTransformer';
+export { default as Engine } from 'json-rules-engine-simplified';

package/dist/conditionals/v2/createConditionalEngineHook.d.ts

@@ -0,0 +1,3 @@
+import { EngineConfig, ConditionalEngineHook } from './types';
+
+export declare function createConditionalEngineHook<T>(config: EngineConfig<T>): ConditionalEngineHook<T>;

package/dist/conditionals/v2/engines/schemaEngineConfig.d.ts

@@ -0,0 +1,4 @@
+import { EngineConfig, SchemaEffect } from '../types';
+import { RJSFSchema } from '@rjsf/utils';
+
+export declare const schemaEngineConfig: EngineConfig<SchemaEffect[], RJSFSchema>;

package/dist/conditionals/v2/engines/uiEngineConfig.d.ts

@@ -0,0 +1,4 @@
+import { EngineConfig, UiEffect } from '../types';
+import { UiSchema } from '@rjsf/utils';
+
+export declare const uiEngineConfig: EngineConfig<UiEffect[], UiSchema>;

package/dist/conditionals/v2/engines/validationEngineConfig.d.ts

@@ -0,0 +1,13 @@
+import { EngineConfig, ValidationEffect } from '../types';
+import { ErrorSchema } from '@rjsf/utils';
+
+export interface ValidationConfig {
+    rules: ValidationEffect[];
+}
+export declare const validationEngineConfig: EngineConfig<ValidationEffect, ValidationConfig>;
+/**
+ * Creates a custom validation function compatible with RJSF
+ * @param validationConfig The validation configuration containing active rules
+ * @returns A validation function that can be passed to RJSF's customValidate prop
+ */
+export declare function createCustomValidate(validationConfig: ValidationConfig): (formData: any, errors: ErrorSchema) => ErrorSchema;

package/dist/conditionals/v2/hooks/useConditionalSchema.d.ts

@@ -0,0 +1,4 @@
+import { Rule, SchemaEffect } from '../types';
+
+export declare const useConditionalSchema: import('..').ConditionalEngineHook<SchemaEffect[]>;
+export type SchemaRule = Rule<SchemaEffect[]>;

package/dist/conditionals/v2/hooks/useConditionalUi.d.ts

@@ -0,0 +1,4 @@
+import { Rule, UiEffect } from '../types';
+
+export declare const useConditionalUi: import('..').ConditionalEngineHook<UiEffect[]>;
+export type UiRule = Rule<UiEffect[]>;

package/dist/conditionals/v2/hooks/useConditionalValidation.d.ts

@@ -0,0 +1,4 @@
+import { Rule, ValidationEffect } from '../types';
+
+export declare const useConditionalValidation: import('..').ConditionalEngineHook<ValidationEffect>;
+export type ValidationRule = Rule<ValidationEffect>;

package/dist/conditionals/v2/index.d.ts

@@ -0,0 +1,10 @@
+export { createConditionalEngineHook } from './createConditionalEngineHook';
+export type { Rule, EngineConfig, ConditionalEngineHook, UiEffect, SchemaEffect, ValidationEffect, } from './types';
+export { useConditionalUi, type UiRule } from './hooks/useConditionalUi';
+export { useConditionalSchema, type SchemaRule, } from './hooks/useConditionalSchema';
+export { useConditionalValidation, type ValidationRule, } from './hooks/useConditionalValidation';
+export { createDynamicArrayItemsUiSchema, mergeItemUiSchema, arrayItemPatterns, type ArrayItemsFunction, type ArrayItemConditionalFn, } from './utils/dynamicArrayItems';
+export { uiEngineConfig } from './engines/uiEngineConfig';
+export { schemaEngineConfig } from './engines/schemaEngineConfig';
+export { validationEngineConfig, createCustomValidate, } from './engines/validationEngineConfig';
+export * from './migration';

package/dist/conditionals/v2/migration.d.ts

@@ -0,0 +1,76 @@
+import { UiRule } from './hooks/useConditionalUi';
+import { SchemaRule } from './hooks/useConditionalSchema';
+
+interface V1Rule {
+    conditions: Record<string, any>;
+    event: {
+        type: string;
+        params?: any;
+    };
+    order?: number;
+}
+interface JsonRulesEngineRule {
+    conditions: {
+        all?: JsonRulesEngineCondition[];
+        any?: JsonRulesEngineCondition[];
+    };
+    event: {
+        type: string;
+        params?: any;
+    };
+}
+interface JsonRulesEngineCondition {
+    fact: string;
+    operator: string;
+    value: any;
+    all?: JsonRulesEngineCondition[];
+    any?: JsonRulesEngineCondition[];
+}
+export interface MigrationReport {
+    totalRules: number;
+    migratedRules: number;
+    manualReviewRequired: Array<{
+        rule: any;
+        reason: string;
+        suggestion: string;
+    }>;
+    warnings: string[];
+}
+/**
+ * Analyzes v1 rules and suggests which pillar they belong to
+ */
+export declare function analyzeRules(rules: V1Rule[]): {
+    uiRules: V1Rule[];
+    schemaRules: V1Rule[];
+    validationRules: V1Rule[];
+    unknown: V1Rule[];
+};
+/**
+ * Migrates v1 rules to v2 UI rules
+ */
+export declare function migrateV1ToUiRules(rules: V1Rule[]): {
+    rules: UiRule[];
+    report: MigrationReport;
+};
+/**
+ * Migrates v1 rules to v2 Schema rules
+ */
+export declare function migrateV1ToSchemaRules(rules: V1Rule[]): {
+    rules: SchemaRule[];
+    report: MigrationReport;
+};
+/**
+ * Migrates JSON Rules Engine format to Three Pillars format
+ */
+export declare function migrateJsonRulesEngine(rules: JsonRulesEngineRule[]): {
+    uiRules: UiRule[];
+    report: MigrationReport;
+};
+/**
+ * Generates a comprehensive migration report
+ */
+export declare function generateMigrationReport(v1Rules: V1Rule[], options?: {
+    includeExamples?: boolean;
+    outputFormat?: 'markdown' | 'json';
+}): string;
+export {};

package/dist/conditionals/v2/types.d.ts

@@ -0,0 +1,37 @@
+import { ErrorSchema } from '@rjsf/utils';
+
+export interface Rule<T> {
+    name: string;
+    condition: (formData: any) => boolean;
+    effect: T;
+    order?: number;
+}
+export interface EngineConfig<T, C = any> {
+    applyEffects: (effects: T[], baseConfig: C, formData: any) => C;
+    defaultConfig: () => C;
+}
+export type ConditionalEngineHook<T, C = any> = (rules: Rule<T>[], baseConfig: C, formData: any) => C;
+export interface UiEffect {
+    op: 'add' | 'remove' | 'replace';
+    path: string;
+    value?: any;
+}
+export interface SchemaEffect {
+    op: 'add' | 'remove' | 'replace';
+    path: string;
+    value?: any;
+}
+export interface ValidationEffect {
+    /**
+     * Name of the validation rule for debugging purposes
+     */
+    name: string;
+    /**
+     * Determines if this validation should be applied based on current form data
+     */
+    isActive: (formData: any) => boolean;
+    /**
+     * Applies validation logic and adds errors to the ErrorSchema
+     */
+    validate: (errors: ErrorSchema, formData: any) => void;
+}

package/dist/conditionals/v2/utils/dynamicArrayItems.d.ts

@@ -0,0 +1,59 @@
+import { UiSchema } from '@rjsf/utils';
+
+/**
+ * Function type for dynamic uiSchema.items in RJSF fork
+ * This enables O(n) performance for array conditionals
+ */
+export type ArrayItemsFunction = (itemData: any, index: number, formContext?: any) => UiSchema;
+/**
+ * Function type for conditional logic applied to array items
+ */
+export type ArrayItemConditionalFn = (itemData: any, index: number, formContext?: any) => Partial<UiSchema>;
+/**
+ * Creates a dynamic uiSchema.items function for array fields
+ *
+ * @param baseItemUiSchema - Base UI schema applied to all array items
+ * @param conditionalLogic - Function that returns conditional UI schema modifications
+ * @returns Function compatible with RJSF fork's dynamic uiSchema.items
+ *
+ * @example
+ * ```typescript
+ * const directorsUiSchema = {
+ *   items: createDynamicArrayItemsUiSchema(
+ *     { 'ui:order': ['name', 'hasShareholding', 'shareholdingPercentage'] },
+ *     (itemData) => {
+ *       if (!itemData?.hasShareholding) {
+ *         return { shareholdingPercentage: { 'ui:widget': 'hidden' } };
+ *       }
+ *       return {};
+ *     }
+ *   )
+ * };
+ * ```
+ */
+export declare function createDynamicArrayItemsUiSchema(baseItemUiSchema: UiSchema, conditionalLogic: ArrayItemConditionalFn): ArrayItemsFunction;
+/**
+ * Safely merges UI schemas with proper handling of nested properties
+ *
+ * @param base - Base UI schema
+ * @param overrides - Conditional UI schema overrides
+ * @returns Merged UI schema
+ */
+export declare function mergeItemUiSchema(base: UiSchema, overrides: Partial<UiSchema>): UiSchema;
+/**
+ * Helper to create common conditional patterns
+ */
+export declare const arrayItemPatterns: {
+    /**
+     * Show/hide a field based on a condition
+     */
+    hideField: (fieldName: string, condition: (itemData: any) => boolean) => ArrayItemConditionalFn;
+    /**
+     * Make a field required based on a condition
+     */
+    requireField: (fieldName: string, condition: (itemData: any) => boolean) => ArrayItemConditionalFn;
+    /**
+     * Apply styles to first/last items
+     */
+    applyIndexStyles: (totalItems: number) => ArrayItemConditionalFn;
+};

package/dist/conditionals/v2/utils/jsonPatch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Simple JSON Patch-like utility for applying operations to objects
+ * Supports add, remove, and replace operations with JSONPath-like syntax
+ */
+export declare function applyPatch(target: any, operations: Array<{
+    op: string;
+    path: string;
+    value?: any;
+}>): any;

package/dist/events/FormEventContext.d.ts

@@ -0,0 +1,19 @@
+import { default as React, ReactNode } from 'react';
+import { FormEventHub } from './FormEventHub';
+
+export interface FormEventContextType {
+    eventHub: FormEventHub;
+    formData?: any;
+}
+export interface FormEventProviderProps {
+    eventHub: FormEventHub;
+    formData?: any;
+    children: ReactNode;
+}
+export declare const FormEventProvider: React.FC<FormEventProviderProps>;
+export declare const useFormEventHub: () => FormEventContextType;
+export declare const useFieldEventHandlers: (fieldId: string, schema?: any, fieldPath?: string[]) => {
+    onFocus: (value: any) => Promise<void>;
+    onBlur: (value: any) => Promise<void>;
+    onChange: (value: any) => Promise<void>;
+};

package/dist/events/FormEventHub.d.ts

@@ -0,0 +1,27 @@
+import { FormEventHandlers, FieldEventHandlers, WebhookConfig } from '../types';
+
+export declare class FormEventHub {
+    private formHandlers;
+    private fieldHandlers;
+    private webhooks;
+    private debounceTimers;
+    private webhookQueue;
+    private isProcessingQueue;
+    constructor(formHandlers: FormEventHandlers, fieldHandlers?: FieldEventHandlers, webhooks?: WebhookConfig[]);
+    handleBeforeSubmit(data: any): Promise<any>;
+    handleAfterSubmit(data: any): Promise<void>;
+    handleBeforeValidation(data: any): Promise<any>;
+    handleAfterValidation(data: any, errors: any): Promise<void>;
+    handleFieldEvent(eventType: 'focus' | 'blur' | 'change', fieldId: string, fieldValue: any, schema?: any, formData?: any, fieldPath?: string[]): Promise<void>;
+    private processWebhooks;
+    private debounceWebhook;
+    private queueWebhook;
+    private processWebhookQueue;
+    private callWebhook;
+    createFieldEventHandlers(fieldId: string, schema?: any, formData?: any, fieldPath?: string[]): {
+        onFocus: (value: any) => Promise<void>;
+        onBlur: (value: any) => Promise<void>;
+        onChange: (value: any) => Promise<void>;
+    };
+    cleanup(): void;
+}

package/dist/events/FormEventManager.d.ts

@@ -0,0 +1,10 @@
+import { FormEventHandlers } from '../types';
+
+export declare class FormEventManager {
+    private handlers;
+    constructor(handlers: FormEventHandlers);
+    handleBeforeSubmit(data: any): Promise<any>;
+    handleAfterSubmit(data: any): Promise<void>;
+    handleBeforeValidation(data: any): Promise<any>;
+    handleAfterValidation(data: any, errors: any): Promise<void>;
+}

package/dist/events/index.d.ts

@@ -0,0 +1,4 @@
+export { FormEventManager } from './FormEventManager';
+export { FormEventHub } from './FormEventHub';
+export { FormEventProvider, useFormEventHub, useFieldEventHandlers, } from './FormEventContext';
+export type { FormEventHandlers, FieldEventHandlers, FormFieldEvent, WebhookConfig, } from '../types';

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useFormDevTools';