reactaform 1.5.0 → 1.8.1

package/dist/components/SubmissionButton.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+export interface SubmissionButtonProps {
+    onClick: () => void;
+    disabled?: boolean;
+    t: (s: string) => string;
+}
+declare const SubmissionButton: React.FC<SubmissionButtonProps>;
+export default SubmissionButton;

package/dist/components/SubmissionMessage.d.ts

@@ -0,0 +1,7 @@
+export interface SubmissionMessageProps {
+    message: string | null;
+    success: boolean | null;
+    onDismiss: () => void;
+    t: (s: string) => string;
+}
+export declare const SubmissionMessage: React.FC<SubmissionMessageProps>;

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+type TooltipProps = {
+    content: string;
+    size?: "small" | "medium" | "large";
+    animation?: boolean;
+};
+declare const Tooltip: React.FC<TooltipProps>;
+export default Tooltip;

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+type CheckboxInputProps = BaseInputProps<boolean, DefinitionPropertyField>;
+export declare const CheckboxInput: React.FC<CheckboxInputProps>;
+export default CheckboxInput;

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

@@ -0,0 +1,13 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+export type ColorInputProps = BaseInputProps<string, DefinitionPropertyField>;
+/**
+ * ColorInput Component
+ * * ---------------------
+ * A reusable color input field that supports a predefined list of color options
+ * (e.g., Red, Blue, etc.) and also allows the user to choose a custom color via
+ * a native HTML `<input type="color">`.
+ *
+ */
+declare const ColorInput: React.FC<ColorInputProps>;
+export default ColorInput;

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

@@ -0,0 +1,11 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+type DateInputProps = BaseInputProps<string, DefinitionPropertyField>;
+/**
+ * DateInput Component
+ * -------------------
+ * Controlled date input for ReactaForm.
+ */
+declare const DateInput: React.FC<DateInputProps>;
+export default DateInput;

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

@@ -0,0 +1,16 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+type DropdownField = DefinitionPropertyField & {
+    options: NonNullable<DefinitionPropertyField['options']>;
+};
+export type DropdownInputProps = BaseInputProps<string, DropdownField>;
+/**
+ * DropdownInput
+ *
+ * Renders a custom dropdown for selecting a single value from options.
+ * - Validates that the selected value is in the options list
+ * - Auto-corrects to first option if invalid value provided
+ * - Uses custom styling from fieldStyle.dropdown
+ */
+declare const DropdownInput: React.FC<DropdownInputProps>;
+export default DropdownInput;

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+import type { DefinitionPropertyField, BaseInputProps } from "../../core/reactaFormTypes";
+export type EmailInputProps = BaseInputProps<string, DefinitionPropertyField>;
+export declare const EmailInput: React.FC<EmailInputProps>;
+export default EmailInput;

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+export type FileInputProps = BaseInputProps<File | File[] | null, DefinitionPropertyField>;
+declare const FileInput: React.FC<FileInputProps>;
+export default FileInput;

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { DefinitionPropertyField, BaseInputProps } from "../../core/reactaFormTypes";
+export type FloatArrayInputProps = BaseInputProps<string | number[], DefinitionPropertyField>;
+/**
+ * FloatArrayInput component
+ */
+declare const FloatArrayInput: React.FC<FloatArrayInputProps>;
+export default FloatArrayInput;

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

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+/**
+ * FloatInput component
+ */
+export type FloatInputProps = BaseInputProps<number | string, DefinitionPropertyField>;
+declare const FloatInput: React.FC<FloatInputProps>;
+export default FloatInput;

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

@@ -0,0 +1,18 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+export type ImageProps = BaseInputProps<string, DefinitionPropertyField>;
+/**
+ * ImageDisplay is a React component that renders an image with optional
+ * localization and flexible layout/styling options.
+ *
+ * Features:
+ * - Localized image fallback based on current language (e.g., _fr, _zhcn suffixes).
+ * - Supports left, center, or right alignment.
+ * - Supports both row and column layout via field.labelLayout property
+ * - Dynamically handles width and height:
+ *    - If both are specified, uses them directly.
+ *    - If only one is specified, uses that and sets the other to `auto`.
+ *    - If neither is specified, renders the image without size constraints.
+ */
+declare const ImageDisplay: React.FC<ImageProps>;
+export default ImageDisplay;

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

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type IntegerArrayInputProps = BaseInputProps<string | number[], DefinitionPropertyField>;
+/**
+ * IntegerArrayInput
+ */
+declare const IntegerArrayInput: React.FC<IntegerArrayInputProps>;
+export default IntegerArrayInput;

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

@@ -0,0 +1,6 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type IntegerInputProps = BaseInputProps<number | string, DefinitionPropertyField>;
+declare const _default: React.NamedExoticComponent<IntegerInputProps>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type OptionsField = DefinitionPropertyField & {
+    options: NonNullable<DefinitionPropertyField["options"]>;
+};
+type MultiSelectionProps = BaseInputProps<string[] | null, OptionsField>;
+declare const MultiSelect: React.FC<MultiSelectionProps>;
+export default MultiSelect;

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

@@ -0,0 +1,6 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+type TextInputProps = BaseInputProps<string, DefinitionPropertyField>;
+declare const MultilineTextInput: React.FC<TextInputProps>;
+export default MultilineTextInput;

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

@@ -0,0 +1,6 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type NumericStepperInputProps = BaseInputProps<string | number, DefinitionPropertyField>;
+declare const NumericStepperInput: React.FC<NumericStepperInputProps>;
+export default NumericStepperInput;

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

@@ -0,0 +1,6 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+type PasswordInputProps = BaseInputProps<string, DefinitionPropertyField>;
+declare const PasswordInput: React.FC<PasswordInputProps>;
+export default PasswordInput;

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

@@ -0,0 +1,6 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+export type PhoneInputProps = BaseInputProps<string, DefinitionPropertyField>;
+export declare const PhoneInput: React.FC<PhoneInputProps>;
+export default PhoneInput;

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+type RadioField = DefinitionPropertyField & {
+    options: NonNullable<DefinitionPropertyField["options"]>;
+};
+export type RadioInputProps = BaseInputProps<string, RadioField>;
+declare const RadioInput: React.FC<RadioInputProps>;
+export default RadioInput;

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

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+type RatingField = DefinitionPropertyField & {
+    max?: number;
+    icon?: string;
+};
+export type RatingInputProps = BaseInputProps<number, RatingField>;
+declare const RatingInput: React.FC<RatingInputProps>;
+export default RatingInput;

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

@@ -0,0 +1,21 @@
+import * as React from "react";
+interface SeparatorProps {
+    color?: string;
+    thickness?: number;
+    margin?: string | number;
+    label?: string | null;
+    alignment?: "left" | "center" | "right";
+}
+export declare const Separator: React.FC<SeparatorProps>;
+interface FieldSeparatorProps {
+    field: {
+        color?: string;
+        thickness?: number;
+        margin?: string | number;
+        label?: string;
+        alignment?: "left" | "center" | "right";
+    };
+    t: (text: string) => string;
+}
+declare const FieldSeparator: React.FC<FieldSeparatorProps>;
+export default FieldSeparator;

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+type SliderInputProps = BaseInputProps<string | number, DefinitionPropertyField>;
+declare const SliderInput: React.FC<SliderInputProps>;
+export default SliderInput;

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+import type { DefinitionPropertyField, BaseInputProps } from "../../core/reactaFormTypes";
+export type SpinInputProps = BaseInputProps<number, DefinitionPropertyField>;
+declare const SpinInput: React.FC<SpinInputProps>;
+export default SpinInput;

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+type SwitchInputProps = BaseInputProps<boolean, DefinitionPropertyField>;
+/**
+ * SwitchInput
+ */
+export declare const SwitchInput: React.FC<SwitchInputProps>;
+export default SwitchInput;

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+type TextInputProps = BaseInputProps<string, DefinitionPropertyField> & {
+    error?: string | null;
+};
+declare const TextInput: React.FC<TextInputProps>;
+export default TextInput;

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

@@ -0,0 +1,6 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+type TimeInputProps = BaseInputProps<string, DefinitionPropertyField>;
+declare const TimeInput: React.FC<TimeInputProps>;
+export default TimeInput;

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

@@ -0,0 +1,5 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../core/reactaFormTypes";
+type UnitValueInputProps = BaseInputProps<[string | number, string], DefinitionPropertyField>;
+declare const _default: React.NamedExoticComponent<UnitValueInputProps>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/reactaFormTypes";
+import type { BaseInputProps } from "../../core/reactaFormTypes";
+/**
+ * UrlInput component
+ */
+export type UrlInputProps = BaseInputProps<string, DefinitionPropertyField>;
+declare const UrlInput: React.FC<UrlInputProps>;
+export default UrlInput;

package/dist/components/renderFields.d.ts

@@ -0,0 +1,3 @@
+import type { DefinitionPropertyField, FieldValueType, ErrorType } from "../core/reactaFormTypes";
+export declare const renderFields: (fields: DefinitionPropertyField[], valuesMap: Record<string, FieldValueType>, handleChange: (fieldName: string, value: FieldValueType, error: ErrorType) => void, visibility: Record<string, boolean>, loadedCount: number, handleError?: (fieldName: string, error: ErrorType) => void, errorsMap?: Record<string, string>) => (import("react/jsx-runtime").JSX.Element | null)[];
+export declare const renderFieldsWithGroups: (groupState: Record<string, boolean>, fields: DefinitionPropertyField[], valuesMap: Record<string, FieldValueType>, t: (key: string) => string, handleChange: (fieldName: string, value: FieldValueType, error: ErrorType) => void, handleError: (fieldName: string, error: ErrorType) => void, visibility: Record<string, boolean>, loadedCount: number, toggleGroup: (groupName: string) => void, errors?: Record<string, string>) => JSX.Element[];

package/dist/core/baseRegistry.d.ts

@@ -0,0 +1,15 @@
+export declare class BaseRegistry<T> {
+    private map;
+    register(name: string, value: T): void;
+    get(name: string): T | undefined;
+    has(name: string): boolean;
+    list(): string[];
+    entries(): [string, T][];
+    values(): T[];
+    size(): number;
+    unregister(name: string): boolean;
+    clear(): void;
+    registerAll(entries: Record<string, T> | [string, T][]): void;
+    getOrDefault(name: string, defaultValue: T): T;
+}
+export default BaseRegistry;

package/dist/core/componentRegistry.d.ts

@@ -0,0 +1,15 @@
+import BaseRegistry from "./baseRegistry";
+export type DebounceConfig = false | {
+    wait?: number;
+    leading?: boolean;
+    trailing?: boolean;
+};
+export declare const DEBOUNCE_CONFIG: Record<string, DebounceConfig>;
+declare const registry: BaseRegistry<unknown>;
+export declare function isBuiltinComponentType(typeName: string): boolean;
+export declare function registerComponentInternal(type: string, component: unknown, isBaseComponent: boolean): void;
+export declare function registerComponent(type: string, component: unknown): void;
+export declare function getComponent(type: string): unknown;
+export declare function listComponents(): string[];
+export declare function registerBaseComponents(): void;
+export default registry;

package/dist/core/env.d.ts

@@ -0,0 +1 @@
+export declare const IS_TEST_ENV: boolean;

package/dist/core/fieldVisibility.d.ts

@@ -0,0 +1,25 @@
+import type { DefinitionPropertyField, FieldValueType } from "./reactaFormTypes";
+/**
+ * Initializes the visibility map for all fields by setting them to `false`.
+ */
+export declare const initializeVisibility: (fields: DefinitionPropertyField[]) => Record<string, boolean>;
+/**
+ * Creates a lookup map for faster field access during visibility calculations
+ */
+export declare const createFieldMap: (fields: DefinitionPropertyField[]) => Record<string, DefinitionPropertyField>;
+/**
+ * Updates visibility map based on current field values and parent-child relationships
+ */
+export declare const updateVisibilityMap: (fields: DefinitionPropertyField[], values: Record<string, FieldValueType>, oldVisibility: Record<string, boolean>, fieldMapRef: Record<string, DefinitionPropertyField>) => Record<string, boolean>;
+/**
+ * Updates visibility when a specific field value changes
+ */
+export declare const updateVisibilityBasedOnSelection: (visibility: Record<string, boolean>, fieldMap: Record<string, DefinitionPropertyField>, valuesMap: Record<string, FieldValueType>, fieldName: string, value: FieldValueType) => Record<string, boolean>;
+/**
+ * Checks if a field should be visible based on its parent relationships
+ */
+export declare const isFieldVisible: (fieldName: string, fieldMap: Record<string, DefinitionPropertyField>, values: Record<string, FieldValueType>) => boolean;
+/**
+ * Gets all visible fields efficiently
+ */
+export declare const getVisibleFields: (fields: DefinitionPropertyField[], values: Record<string, FieldValueType>) => DefinitionPropertyField[];

package/dist/core/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/pluginRegistry.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Enhanced Plugin Registry for ReactaForm
+ * Tracks installed plugins, components, validators, submission handlers
+ * Handles conflicts with customizable strategy
+ */
+import type { FieldCustomValidationHandler, FieldTypeValidationHandler, FormValidationHandler, FormSubmissionHandler } from './reactaFormTypes';
+/** Conflict resolution strategies */
+export type ConflictResolution = 'error' | 'warn' | 'override' | 'skip';
+/** Plugin registration options */
+export interface PluginRegistrationOptions {
+    conflictResolution?: ConflictResolution;
+    onConflict?: (conflict: PluginConflict) => boolean;
+}
+/** Plugin conflict information */
+export interface PluginConflict {
+    type: 'component' | 'fieldCustomValidator' | 'fieldTypeValidator' | 'formValidator' | 'submissionHandler' | 'plugin';
+    name: string;
+    existingPlugin: string;
+    newPlugin: string;
+}
+/** ReactaForm plugin definition */
+export interface ReactaFormPlugin {
+    name: string;
+    version: string;
+    description?: string;
+    components?: Record<string, React.ComponentType<unknown>>;
+    fieldCustomValidators?: Record<string, Record<string, FieldCustomValidationHandler>>;
+    fieldTypeValidators?: Record<string, FieldTypeValidationHandler>;
+    formValidators?: Record<string, FormValidationHandler>;
+    submissionHandlers?: Record<string, FormSubmissionHandler>;
+    setup?: () => void;
+    cleanup?: () => void;
+}
+/** Register a plugin */
+export declare function registerPlugin(plugin: ReactaFormPlugin, options?: PluginRegistrationOptions): void;
+/** Unregister plugin */
+export declare function unregisterPlugin(pluginName: string, removeRegistrations?: boolean): boolean;
+/** Get a plugin by name */
+export declare function getPlugin(pluginName: string): ReactaFormPlugin | undefined;
+/** Get all installed plugins */
+export declare function getAllPlugins(): ReactaFormPlugin[];
+/** Check if plugin is registered */
+export declare function hasPlugin(pluginName: string): boolean;
+/** Helper to register multiple components at once */
+export declare function registerComponents(components: Record<string, React.ComponentType<unknown>>): void;

package/dist/core/reactaFormModel.d.ts

@@ -0,0 +1,31 @@
+import type { ReactaDefinition, ReactaInstance } from "./reactaFormTypes";
+export interface LoadDefinitionOptions {
+    validateSchema?: boolean;
+}
+export interface DefinitionLoadResult {
+    success: boolean;
+    definition?: ReactaDefinition;
+    error?: string;
+}
+export interface InstanceLoadResult {
+    success: boolean;
+    instance?: ReactaInstance;
+    error?: string;
+}
+/**
+ * Validates that a definition object has the required structure
+ */
+export declare function validateDefinitionSchema(definition: ReactaDefinition): string | null;
+/**
+ * Load definition from a JSON string. This intentionally does not perform any file I/O.
+ */
+export declare function loadJsonDefinition(jsonData: string, options?: LoadDefinitionOptions): Promise<DefinitionLoadResult>;
+/**
+ * Create instance from definition with validation and error handling
+ */
+export declare function createInstanceFromDefinition(definition: ReactaDefinition, name: string): InstanceLoadResult;
+/**
+ * Load instance data with validation
+ */
+export declare function loadInstance(instanceData: string | Record<string, unknown>): InstanceLoadResult;
+export declare function upgradeInstanceToLatestDefinition(oldInstance: ReactaInstance, latestDefinition: ReactaDefinition, callback?: (oldInstance: ReactaInstance, newInstance: Record<string, unknown>, latestDefinition: ReactaDefinition) => void): InstanceLoadResult;

package/dist/core/reactaFormTypes.d.ts

@@ -0,0 +1,148 @@
+import type { ReactNode } from 'react';
+type Integer = number;
+type Float = number;
+export type FieldValueType = boolean | Integer | Float | string | Integer[] | Float[] | string[] | [number, string] | File | File[];
+export type ErrorType = string | null;
+export type ParentField = Record<string, string[] | Integer[] | boolean[]>;
+export type ValidationHandlerName = string | [string] | [string, string];
+export interface DefinitionPropertyField {
+    name: string;
+    displayName: string;
+    type: string;
+    defaultValue: FieldValueType;
+    required?: boolean;
+    parents?: ParentField;
+    children?: Record<string, string[]>;
+    group?: string;
+    tooltip?: string;
+    labelLayout?: 'row' | 'column-left' | 'column-center';
+    validationHandlerName?: ValidationHandlerName;
+    dimension?: string;
+    defaultUnit?: string;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    patternErrorMessage?: string;
+    placeholder?: string;
+    min?: number;
+    max?: number;
+    minInclusive?: boolean;
+    maxInclusive?: boolean;
+    step?: number;
+    minCount?: number;
+    maxCount?: number;
+    minDate?: string;
+    maxDate?: string;
+    includeSeconds?: boolean;
+    layout?: 'horizontal' | 'vertical' | 'row' | 'column';
+    alignment?: 'left' | 'center' | 'right';
+    width?: number;
+    height?: number;
+    localized?: string;
+    minHeight?: string;
+    accept?: string;
+    multiple?: boolean;
+    allowRelative?: boolean;
+}
+export interface ReactaDefinition {
+    name: string;
+    version: string;
+    displayName: string;
+    localization?: string;
+    properties: DefinitionPropertyField[];
+    validationHandlerName?: string;
+    submitHandlerName?: string;
+}
+export interface ReactaInstance {
+    name: string;
+    definition: string;
+    version: string;
+    values: Record<string, FieldValueType>;
+}
+export interface ReactaFormProps {
+    definitionData: string | Record<string, unknown>;
+    language?: string;
+    instance?: ReactaInstance;
+    className?: string;
+    theme?: string;
+    style?: React.CSSProperties;
+    fieldValidationMode?: FieldValidationMode;
+}
+export type TranslationFunction = (text: string, ...args: unknown[]) => string;
+/** Validation mode controls where validation is performed. */
+export type FieldValidationMode = 'realTime' | 'onSubmission';
+export type FieldCustomValidationHandler = (fieldName: string, value: FieldValueType | unknown, t: TranslationFunction) => string | undefined;
+export type FieldTypeValidationHandler = (field: DefinitionPropertyField, input: FieldValueType, t: TranslationFunction) => string | null;
+export type FormValidationHandler = (valuesMap: Record<string, FieldValueType | unknown>, t: TranslationFunction) => string[] | undefined | Promise<string[] | undefined>;
+export type FormSubmissionHandler = (definition: ReactaDefinition, instanceName: string | null, valuesMap: Record<string, FieldValueType | unknown>, t: TranslationFunction) => string[] | undefined | Promise<string[] | undefined>;
+export type InputOnChange<T> = (value: T | string) => void;
+export interface BaseInputProps<TValue = unknown, TField extends DefinitionPropertyField = DefinitionPropertyField> {
+    field: TField;
+    value: TValue;
+    placeholder?: string;
+    onChange?: InputOnChange<TValue>;
+    onError?: (error: string | null) => void;
+    error?: string | null;
+}
+export type ReactaFormContextType = {
+    definitionName: string;
+    language: string;
+    theme: string;
+    formStyle: {
+        container?: React.CSSProperties;
+        titleStyle?: React.CSSProperties;
+    };
+    fieldStyle: Record<string, unknown>;
+    t: TranslationFunction;
+    fieldValidationMode?: FieldValidationMode;
+};
+export type ReactaFormProviderProps = {
+    children: ReactNode;
+    definitionName?: string;
+    defaultStyle?: Record<string, unknown>;
+    defaultLanguage?: string;
+    defaultTheme?: string;
+    defaultLocalizeName?: string;
+    defaultFieldValidationMode?: FieldValidationMode;
+    className?: string;
+};
+export type TranslationMap = Record<string, string>;
+export type TranslationCache = Map<string, TranslationMap>;
+export interface RegistryResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export interface FieldGroup {
+    name: string;
+    displayName: string;
+    description?: string;
+    collapsed?: boolean;
+    order?: number;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings?: string[];
+}
+export type FormEventType = 'init' | 'change' | 'validate' | 'submit' | 'reset';
+export interface FormEvent {
+    type: FormEventType;
+    timestamp: Date;
+    data?: unknown;
+}
+export interface EnhancedDefinitionPropertyField extends DefinitionPropertyField {
+    category?: string;
+    tags?: string[];
+    dependencies?: string[];
+    conditional?: {
+        field: string;
+        value: unknown;
+        operator?: 'equals' | 'not_equals' | 'contains' | 'greater_than' | 'less_than';
+    };
+}
+export {};

package/dist/core/submissionHandlerRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { FormSubmissionHandler } from "./reactaFormTypes";
+import BaseRegistry from "./baseRegistry";
+declare const registry: BaseRegistry<FormSubmissionHandler>;
+export declare function registerSubmissionHandler(submitterName: string, fn: FormSubmissionHandler): void;
+export declare function getFormSubmissionHandler(submitterName: string): FormSubmissionHandler | undefined;
+export declare function getSubmissionHandler(submitterName: string): FormSubmissionHandler | undefined;
+export default registry;

package/dist/core/submitForm.d.ts

@@ -0,0 +1,9 @@
+import type { ReactaDefinition, FieldValueType, ReactaInstance, TranslationFunction } from "./reactaFormTypes";
+export interface SubmitResult {
+    success: boolean;
+    message: string;
+    data?: Record<string, unknown>;
+    errors?: string[];
+}
+export declare function submitForm(definition: ReactaDefinition, instance: ReactaInstance | null, valuesMap: Record<string, FieldValueType | unknown>, t: TranslationFunction, errors: Record<string, string>): Promise<SubmitResult>;
+export default submitForm;