@formitiva/react 0.9.0

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

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

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

@@ -0,0 +1,8 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField } from "../../../core/formitivaTypes";
+type DropdownField = DefinitionPropertyField & {
+    options: NonNullable<DefinitionPropertyField['options']>;
+};
+export type DropdownInputProps = BaseInputProps<string, DropdownField>;
+declare const _default: React.NamedExoticComponent<DropdownInputProps>;
+export default _default;

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

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

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

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

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

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

package/dist/components/fields/date-time/DateInput.d.ts

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

package/dist/components/fields/date-time/TimeInput.d.ts

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

package/dist/components/fields/text-numeric/FloatArrayInput.d.ts

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

package/dist/components/fields/text-numeric/FloatInput.d.ts

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

package/dist/components/fields/text-numeric/IntegerArrayInput.d.ts

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

package/dist/components/fields/text-numeric/IntegerInput.d.ts

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

package/dist/components/fields/text-numeric/MultilineTextInput.d.ts

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

package/dist/components/fields/text-numeric/NumericStepperInput.d.ts

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

package/dist/components/fields/text-numeric/TextInput.d.ts

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

package/dist/components/fields/ui-elements/Button.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import type { BaseInputProps, DefinitionPropertyField, FieldValueType, ErrorType } from "../../../core/formitivaTypes";
+/**
+ * Extended props for Button component
+ * Unlike other fields, Button needs access to all form values
+ * and the ability to change any field
+ */
+export interface ButtonInputProps extends BaseInputProps<null, DefinitionPropertyField> {
+    valuesMap: Record<string, FieldValueType>;
+    handleChange: (fieldName: string, value: FieldValueType) => void;
+    handleError: (fieldName: string, error: ErrorType) => void;
+}
+declare const _default: React.NamedExoticComponent<ButtonInputProps>;
+export default _default;

package/dist/components/fields/ui-elements/Description.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+interface DescriptionProps {
+    field: {
+        displayText?: string;
+        textAlign?: "left" | "center" | "right";
+        allowHtml?: boolean;
+    };
+}
+declare const _default: React.NamedExoticComponent<DescriptionProps>;
+export default _default;

package/dist/components/fields/ui-elements/ImageDisplay.d.ts

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

package/dist/components/fields/ui-elements/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 _default: React.NamedExoticComponent<FieldSeparatorProps>;
+export default _default;

package/dist/components/form/Formitiva.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import type { FormitivaProps } from "../../core/formitivaTypes";
+/**
+ * Formitiva component - The main form rendering component
+ * @param {FormitivaProps} props - The component props
+ * @param {string | Record<string, unknown> | FormitivaDefinition} props.definitionData - Form definition data (JSON string, object, or FormitivaDefinition)
+ * @param {FormitivaInstance} [props.instance] - Optional form instance with saved values
+ * @param {string} [props.language] - Language code for localization
+ * @param {string} [props.className] - Additional CSS class names
+ * @param {string} [props.theme] - Theme name ('light' or 'dark')
+ * @param {React.CSSProperties} [props.style] - Inline styles
+ * @param {FieldValidationMode} [props.fieldValidationMode] - Field Validation mode ('onEdit', 'onBlur', 'onSubmission', 'realTime' [deprecated])
+ * @param {boolean} [props.displayInstanceName] - Whether to display the instance name
+ */
+declare const Formitiva: React.FC<FormitivaProps>;
+export default Formitiva;

package/dist/components/form/FormitivaProvider.d.ts

@@ -0,0 +1,18 @@
+import type { FieldValidationMode, FormitivaProviderProps } from '../../core/formitivaTypes';
+import '../../styles/formitiva.css';
+/**
+ * FormitivaProvider component - Context provider for Formitiva configuration
+ * @param {FormitivaProviderProps} props - The component props
+ * @param {ReactNode} props.children - Child components to wrap with context
+ * @param {string} [props.definitionName] - Name of the form definition
+ * @param {Record<string, unknown>} [props.defaultStyle] - Default styling configuration
+ * @param {string} [props.defaultLanguage='en'] - Default language code for translations
+ * @param {string} [props.defaultTheme='light'] - Default theme name
+ * @param {string} [props.defaultLocalizeName] - Name of custom localization file
+ * @param {FieldValidationMode} [props.defaultFieldValidationMode='onEdit'] - Field Validation mode
+ * @param {string} [props.className='formitiva-container'] - CSS class name for the container
+ * @param {boolean} [props.displayInstanceName] - Whether to display the instance name
+ */
+export declare const FormitivaProvider: ({ children, definitionName, defaultStyle, defaultLanguage, defaultTheme, defaultLocalizeName, defaultFieldValidationMode, className, defaultDisplayInstanceName }: FormitivaProviderProps & {
+    defaultFieldValidationMode?: FieldValidationMode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/form/FormitivaRenderer.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import type { FormitivaDefinition, FormitivaInstance, FormSubmissionHandler, FormValidationHandler } from "../../core/formitivaTypes";
+export interface FormitivaRendererProps {
+    definition: FormitivaDefinition;
+    instance: FormitivaInstance;
+    onSubmit?: FormSubmissionHandler;
+    onValidation?: FormValidationHandler;
+    chunkSize?: number;
+    chunkDelay?: number;
+}
+/**
+ * FormitivaRenderer component - Internal form renderer with field management
+ * @param {FormitivaRendererProps} props - The component props
+ * @param {FormitivaDefinition} props.definition - The form definition object
+ * @param {FormitivaInstance} props.instance - The form instance with values
+ * @param {number} [props.chunkSize=50] - Number of fields to render per chunk for performance
+ * @param {number} [props.chunkDelay=50] - Delay in ms between rendering chunks
+ */
+declare const FormitivaRenderer: React.FC<FormitivaRendererProps>;
+export default FormitivaRenderer;

package/dist/components/form/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/form/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/layout/FieldGroup.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import type { DefinitionPropertyField, FieldValueType, ErrorType } from "../../core/formitivaTypes";
+export interface FieldGroupProps {
+    groupName: string;
+    defaultOpen?: boolean;
+    fields: DefinitionPropertyField[];
+    valuesMap: Record<string, FieldValueType>;
+    handleChange: (fieldName: string, value: FieldValueType) => void;
+    handleError?: (fieldName: string, error: ErrorType) => void;
+    errorsMap?: Record<string, string>;
+    t: (key: string) => string;
+}
+/**
+ * Self-managing collapsible field group component with internal toggle state
+ */
+export declare const FieldGroup: React.NamedExoticComponent<FieldGroupProps>;

package/dist/components/layout/FieldRenderer.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import type { DefinitionPropertyField, FieldValueType, ErrorType } from "../../core/formitivaTypes";
+export interface FieldRendererProps {
+    field: DefinitionPropertyField;
+    valuesMap: Record<string, FieldValueType>;
+    handleChange: (fieldName: string, value: FieldValueType) => void;
+    handleError?: (fieldName: string, error: ErrorType) => void;
+    errorsMap?: Record<string, string>;
+}
+/**
+ * Memoized component for rendering a single field with error handling
+ * and optimized re-render prevention
+ */
+export declare const FieldRenderer: React.NamedExoticComponent<FieldRendererProps>;

package/dist/components/layout/LayoutComponents.d.ts

@@ -0,0 +1,77 @@
+import * as React from "react";
+import type { DefinitionPropertyField } from "../../core/formitivaTypes";
+/**
+ * ColumnFieldLayout - Vertical layout wrapper for form fields
+ *
+ * This component provides a column-based layout pattern:
+ * - Label on top (left-aligned or center-aligned based on labelLayout)
+ * - Value/input area below
+ * - Optional tooltip support
+ * - Error display area
+ *
+ * Usage:
+ * <ColumnFieldLayout field={field} error={error}>
+ *   <textarea ... />
+ * </ColumnFieldLayout>
+ */
+export declare const ColumnFieldLayout: React.MemoExoticComponent<({ field, error, children, showLabel, }: {
+    field: DefinitionPropertyField;
+    error?: string | null;
+    children: React.ReactNode;
+    showLabel?: boolean;
+}) => import("react/jsx-runtime").JSX.Element>;
+/**
+ * RowFieldLayout - Horizontal layout wrapper for form fields
+ *
+ * This component provides the traditional two-column layout pattern:
+ * - Label on the left using CSS_CLASSES.label
+ * - Value/input area on the right
+ * - Optional tooltip support
+ * - Error display area
+ *
+ * Usage:
+ * <RowFieldLayout field={field} error={error}>
+ *   <input ... />
+ * </RowFieldLayout>
+ */
+export declare const RowFieldLayout: React.MemoExoticComponent<({ field, error, children, rightAlign, }: {
+    field: DefinitionPropertyField;
+    error?: string | null;
+    children: React.ReactNode;
+    rightAlign?: boolean;
+}) => import("react/jsx-runtime").JSX.Element>;
+/**
+ * StandardFieldLayout - Smart layout wrapper that delegates to appropriate layout component
+ *
+ * This component automatically chooses between row and column layouts based on field.labelLayout:
+ * - Uses ColumnFieldLayout when field.labelLayout === 'column'
+ * - Uses RowFieldLayout for default/row layout
+ * - Maintains consistent API for all field components
+ *
+ * Usage:
+ * <StandardFieldLayout field={field} error={error}>
+ *   <input ... />
+ * </StandardFieldLayout>
+ */
+export declare const StandardFieldLayout: React.MemoExoticComponent<({ field, error, children, rightAlign, }: {
+    field: DefinitionPropertyField;
+    error?: string | null;
+    children: React.ReactNode;
+    rightAlign?: boolean;
+}) => import("react/jsx-runtime").JSX.Element>;
+export declare const ErrorDiv: React.MemoExoticComponent<({ children, id }: {
+    children: React.ReactNode;
+    id?: string;
+}) => import("react/jsx-runtime").JSX.Element>;
+/**
+ * InstanceName - display and edit an instance name in a compact grid row
+ *                on top of fields list
+ *
+ * Props:
+ * - `name`: current instance name
+ * - `onChange`: callback invoked with new name when edited
+ */
+export declare const InstanceName: React.MemoExoticComponent<({ name, onChange }: {
+    name: string;
+    onChange: (n: string) => void;
+}) => import("react/jsx-runtime").JSX.Element>;

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,13 @@
+import type { DefinitionPropertyField, FieldValueType } from "./formitivaTypes";
+/**
+ * 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;

package/dist/core/formitivaModel.d.ts

@@ -0,0 +1,31 @@
+import type { FormitivaDefinition, FormitivaInstance } from "./formitivaTypes";
+export interface LoadDefinitionOptions {
+    validateSchema?: boolean;
+}
+export interface DefinitionLoadResult {
+    success: boolean;
+    definition?: FormitivaDefinition;
+    error?: string;
+}
+export interface InstanceLoadResult {
+    success: boolean;
+    instance?: FormitivaInstance;
+    error?: string;
+}
+/**
+ * Validates that a definition object has the required structure
+ */
+export declare function validateDefinitionSchema(definition: FormitivaDefinition): 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: FormitivaDefinition, name: string): InstanceLoadResult;
+/**
+ * Load instance data with validation
+ */
+export declare function loadInstance(instanceData: string | Record<string, unknown>): InstanceLoadResult;
+export declare function upgradeInstanceToLatestDefinition(oldInstance: FormitivaInstance, latestDefinition: FormitivaDefinition, callback?: (oldInstance: FormitivaInstance, newInstance: Record<string, unknown>, latestDefinition: FormitivaDefinition) => void): InstanceLoadResult;

package/dist/core/formitivaTypes.d.ts

@@ -0,0 +1,128 @@
+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;
+    disabled?: boolean;
+    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;
+    action?: string;
+    displayText?: string;
+    textAlign?: 'left' | 'center' | 'right';
+}
+export interface FormitivaDefinition {
+    name: string;
+    version: string;
+    displayName: string;
+    localization?: string;
+    properties: DefinitionPropertyField[];
+    validationHandlerName?: string;
+    submitHandlerName?: string;
+}
+export interface FormitivaInstance {
+    name: string;
+    definition: string;
+    version: string;
+    values: Record<string, FieldValueType>;
+}
+export interface FormitivaProps {
+    definitionData: string | Record<string, unknown> | FormitivaDefinition;
+    language?: string;
+    instance?: FormitivaInstance;
+    className?: string;
+    theme?: string;
+    style?: React.CSSProperties;
+    fieldValidationMode?: FieldValidationMode;
+    displayInstanceName?: boolean;
+    onSubmit?: FormSubmissionHandler;
+    onValidation?: FormValidationHandler;
+}
+export type TranslationFunction = (text: string, ...args: unknown[]) => string;
+/** Validation mode controls where validation is performed.
+ * 'onEdit' (default) - Validate fields as they are edited, showing errors immediately.
+ * 'onBlur' - Validate fields when they lose focus, reducing validation work while typing.
+ * 'onSubmission' - Validate only when the form is submitted, showing errors after submission attempt.
+ * 'realTime' - deprecated, use 'onEdit' instead.
+ */
+export type FieldValidationMode = 'onEdit' | 'onBlur' | 'onSubmission' | 'realTime';
+export type FieldCustomValidationHandler = (fieldName: string, value: FieldValueType | unknown, t: TranslationFunction) => string | undefined;
+export type FieldTypeValidationHandler = (field: DefinitionPropertyField, input: FieldValueType, t: TranslationFunction) => string | undefined;
+export type FormValidationHandler = (valuesMap: Record<string, FieldValueType | unknown>, t: TranslationFunction) => string[] | Promise<string[] | undefined> | undefined;
+export type FormSubmissionHandler = (definition: FormitivaDefinition, 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;
+    disabled?: boolean;
+    placeholder?: string;
+    onChange?: InputOnChange<TValue>;
+    onError?: (error: string | null) => void;
+    error?: string | null;
+}
+export type FormitivaContextType = {
+    definitionName: string;
+    language: string;
+    theme: string;
+    formStyle: {
+        container?: React.CSSProperties;
+        titleStyle?: React.CSSProperties;
+    };
+    fieldStyle: Record<string, unknown>;
+    t: TranslationFunction;
+    fieldValidationMode: FieldValidationMode;
+    displayInstanceName: boolean;
+};
+export type FormitivaProviderProps = {
+    children: ReactNode;
+    definitionName?: string;
+    defaultStyle?: Record<string, unknown>;
+    defaultLanguage?: string;
+    defaultTheme?: string;
+    defaultLocalizeName?: string;
+    defaultFieldValidationMode?: FieldValidationMode;
+    className?: string;
+    defaultDisplayInstanceName?: boolean;
+};
+export {};

package/dist/core/registries/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/registries/buttonHandlerRegistry.d.ts

@@ -0,0 +1,44 @@
+import type { FieldValueType, ErrorType, TranslationFunction } from "../formitivaTypes";
+import BaseRegistry from "./baseRegistry";
+/**
+ * Button Handler function type
+ * Button handlers can access all form values, change any field value, and report errors
+ *
+ * @param valuesMap - All form values (read-only)
+ * @param handleChange - Function to update any field's value
+ * @param handleError - Function to report errors for any field
+ * @param t - Translation function
+ * @returns void or Promise<void>
+ */
+export type ButtonHandler = (valuesMap: Record<string, FieldValueType>, handleChange: (fieldName: string, value: FieldValueType) => void, handleError: (fieldName: string, error: ErrorType) => void, t: TranslationFunction) => void | Promise<void>;
+declare const registry: BaseRegistry<ButtonHandler>;
+/**
+ * Register a button handler function
+ * @param handlerName - The name to register the handler under (referenced in definition's action property)
+ * @param fn - The button handler function
+ */
+export declare function registerButtonHandler(handlerName: string, fn: ButtonHandler): void;
+/**
+ * Get a registered button handler by name
+ * @param handlerName - The name of the handler to retrieve
+ * @returns The button handler function or undefined if not found
+ */
+export declare function getButtonHandler(handlerName: string): ButtonHandler | undefined;
+/**
+ * Check if a button handler is registered
+ * @param handlerName - The name of the handler to check
+ * @returns true if the handler is registered, false otherwise
+ */
+export declare function hasButtonHandler(handlerName: string): boolean;
+/**
+ * Unregister a button handler
+ * @param handlerName - The name of the handler to unregister
+ * @returns true if the handler was found and removed, false otherwise
+ */
+export declare function unregisterButtonHandler(handlerName: string): boolean;
+/**
+ * List all registered button handler names
+ * @returns Array of registered handler names
+ */
+export declare function listButtonHandlers(): string[];
+export default registry;

package/dist/core/registries/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;