@4riders/reform 3.0.24

package/dist/index.d.ts

@@ -0,0 +1,2715 @@
+import { default as default_2 } from 'react';
+import { DOMAttributes } from 'react';
+import { FormEvent } from 'react';
+import { FormHTMLAttributes } from 'react';
+import { InputHTMLAttributes } from 'react';
+import { JSX as JSX_2 } from 'react';
+import { JSX as JSX_3 } from 'react/jsx-runtime';
+import { SelectHTMLAttributes } from 'react';
+import { TextareaHTMLAttributes } from 'react';
+
+/**
+ * Decorator for validating a field value as an array of a specified element type. The `of` property can be set to a custom
+ * class constructor, or a validation decorator such as {@link string}, {@link number}, etc. Using a validation decorator allows
+ * applying constraints to each array element.
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *
+ *     // the array itself must not be null, but its elements may be null
+ *     ＠array({ of: Dog, required: true })
+ *     dogs: Dog[] | null = null
+ *
+ *     // the array must not be null, and all its elements must also be non-null
+ *     ＠array({ of: instance({ of: Cat, required: true }), required: true })
+ *     cats: Cat[] | null = null
+ *
+ *     // a non-empty array of strings with at least 5 characters each
+ *     ＠array({ of: string({ required: true, min: 5 }), required: true, min: 1 })
+ *     names: string[] | null = null
+ * }
+ * const form = useForm(Person, ...)
+ *
+ * // the array decorator can also be used as a function to allow standalone validation:
+ * Yop.validate([], array({ of: Dog, min: 1 })) // error: "At least 1 element"
+ * ```
+ *
+ * @template Value - The type of the array value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The array constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export declare function array<Value extends ArrayValue, Parent>(constraints?: ArrayConstraints<Value, Parent>, groups?: Groups<ArrayConstraints<Value, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Interface for array field constraints, combining common, min/max, test, and element type constraints.
+ * @template Value - The type of the array value.
+ * @template Parent - The type of the parent object.
+ * @see {@link id}
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export declare interface ArrayConstraints<Value extends ArrayValue, Parent> extends CommonConstraints<Value, Parent>, MinMaxConstraints<Value, number, Parent>, TestConstraint<Value, Parent> {
+    /**
+     * A class constructor, a function returning a constructor, a validation decorator, or a class id (see {@link id}) to
+     * validate each array element against.
+     * @see {@link array}
+     */
+    of: (Constructor<ArrayElementType<Value>> | (() => Constructor<ArrayElementType<Value>>) | ((_: any, context: ClassFieldDecoratorContext<Value, ArrayElementType<Value>>) => void) | string);
+}
+
+/**
+ * Type for extracting the element type from an array type.
+ * @template ArrayType - The array type.
+ * @ignore
+ */
+export declare type ArrayElementType<ArrayType> = ArrayType extends Array<infer ElementType> ? ElementType : never;
+
+/**
+ * Utility class for manipulating array fields in a form model, with automatic touch, validation, and rendering. See {@link FormManager.array} for details.
+ * @template T - The type of array elements.
+ * @category Form Management
+ */
+export declare class ArrayHelper<T = any> {
+    readonly form: InternalFormManager<any>;
+    readonly path: string | Path;
+    private array;
+    /**
+     * Creates an ArrayHelper for a given form and path.
+     * @param form - The form manager instance.
+     * @param path - The path to the array field in the form.
+     */
+    constructor(form: InternalFormManager<any>, path: string | Path);
+    /**
+     * Tells if the field at the given path was an array.
+     * @returns True if the field was an array, false otherwise.
+     */
+    isArray(): boolean;
+    /**
+     * Appends an element to the array.
+     * @param element - The element to append.
+     * @param commit - Whether to validate and render after the operation (default: true).
+     */
+    append(element: T, commit?: boolean): void;
+    /**
+     * Replaces the element at the given index.
+     * @param index - The index to replace.
+     * @param element - The new element.
+     * @param commit - Whether to validate and render after the operation (default: true).
+     */
+    replace(index: number, element: T, commit?: boolean): void;
+    /**
+     * Inserts an element at the given index.
+     * @param index - The index to insert at.
+     * @param element - The element to insert.
+     * @param commit - Whether to validate and render after the operation (default: true).
+     */
+    insert(index: number, element: T, commit?: boolean): void;
+    /**
+     * Removes the element at the given index.
+     * @param index - The index to remove.
+     * @param commit - Whether to validate and render after the operation (default: true).
+     */
+    remove(index: number, commit?: boolean): void;
+    /**
+     * Swaps two elements in the array.
+     * @param index1 - The first index.
+     * @param index2 - The second index.
+     * @param commit - Whether to validate and render after the operation (default: true).
+     */
+    swap(index1: number, index2: number, commit?: boolean): void;
+    /**
+     * Moves an element from one index to another.
+     * @param from - The source index.
+     * @param to - The destination index.
+     * @param commit - Whether to validate and render after the operation (default: true).
+     */
+    move(from: number, to: number, commit?: boolean): void;
+    /**
+     * Removes all elements from the array.
+     * @param commit - Whether to validate and render after the operation (default: true).
+     */
+    clear(commit?: boolean): void;
+    /**
+     * Validates and renders the form if value is true.
+     * @param value - Whether to commit (validate and render).
+     */
+    private commit;
+}
+
+/**
+ * Constant representing the kind of array validation decorator.
+ * @ignore
+ */
+export declare const arrayKind = "array";
+
+/**
+ * Type for an array value, which can be an array, null, or undefined.
+ * @ignore
+ */
+export declare type ArrayValue = any[] | null | undefined;
+
+/**
+ * Assigns properties from source to target, with options for skipping undefined, including, or excluding keys.
+ * @template T - The target type.
+ * @template U - The source type.
+ * @param target - The target object.
+ * @param source - The source object.
+ * @param options - Optional settings for assignment.
+ * @returns The merged object.
+ * @category Utilities
+ */
+export declare function assign<T extends {}, U>(target: T, source: U, options?: {
+    skipUndefined?: boolean;
+    includes?: (keyof U)[];
+    excludes?: (keyof U)[];
+}): T & U;
+
+/**
+ * Interface for an asynchronous test constraint.
+ * @template Value - The type of the value being validated.
+ * @template Parent - The type of the parent object.
+ * @property promise - Function returning a promise for the constraint message.
+ * @property pendingMessage - Message to show while pending.
+ * @property unavailableMessage - Message to show if async service is unavailable.
+ * @property dependencies - Function to get dependencies for revalidation.
+ * @property revalidate - Function to determine if revalidation is needed.
+ * @category Shared Constraints
+ */
+export declare interface AsyncTestConstraint<Value, Parent = unknown> {
+    promise: (context: ValidationContext<NonNullable<Value>, Parent>) => Promise<TestConstraintMessage>;
+    pendingMessage?: ConstraintMessage;
+    unavailableMessage?: ConstraintMessage;
+    dependencies?: (context: InternalValidationContext<Value, Parent>) => any[];
+    revalidate?: (context: InternalValidationContext<Value, Parent>, previous: any[], current: any[], status: ValidationStatus | undefined) => boolean;
+}
+
+/**
+ * Type for async validation status, including dependencies.
+ * @category Validation Management
+ */
+export declare type AsyncValidationStatus = {
+    /**
+     * The current validation status, which can be "pending", "unavailable", or a regular validation status.
+     */
+    status?: ValidationStatus | undefined;
+    /**
+     * The dependencies for the asynchronous validation.
+     */
+    dependencies: any[];
+};
+
+/**
+ * A base checkbox field component that can be used to create custom checkbox input components connected to the form state.
+ * @category Base Inputs Components
+ */
+export declare function BaseCheckboxField(props: BaseCheckboxFieldProps): JSX_3.Element;
+
+/**
+ * @ignore
+ */
+export declare type BaseCheckboxFieldHTMLAttributes = Omit<InputAttributes<'checkbox'>, 'accept' | 'alt' | 'autocomplete' | 'capture' | 'dirname' | 'height' | 'list' | 'max' | 'maxLength' | 'min' | 'minLength' | 'multiple' | 'placeholder' | 'readOnly' | 'size' | 'src' | 'step' | 'type' | 'width'>;
+
+/**
+ * @category Base Inputs Components
+ */
+export declare type BaseCheckboxFieldProps = BaseCheckboxFieldHTMLAttributes & Omit<ReformEvents<boolean>, 'onBlur'> & {
+    render: () => void;
+};
+
+/**
+ * A base date field component that can be used to create custom date input components connected to the form state.
+ * @category Base Inputs Components
+ */
+export declare function BaseDateField(props: BaseDateFieldProps): JSX_3.Element;
+
+/**
+ * @category Base Inputs Components
+ */
+declare type BaseDateFieldProps = BaseTextFieldHTMLAttributes & ReformEvents<Date> & {
+    render: () => void;
+};
+
+/**
+ * A base radio field component that can be used to create custom radio input components connected to the form state.
+ * @category Base Inputs Components
+ */
+export declare function BaseRadioField<V = any>(props: BaseRadioFieldProps<V>): JSX_3.Element;
+
+/**
+ * @ignore
+ */
+export declare type BaseRadioFieldHTMLAttributes = Omit<InputAttributes<'radio'>, 'accept' | 'alt' | 'autocomplete' | 'capture' | 'dirname' | 'height' | 'list' | 'max' | 'maxLength' | 'min' | 'minLength' | 'multiple' | 'placeholder' | 'readOnly' | 'size' | 'src' | 'step' | 'type' | 'width'>;
+
+/**
+ * @category Base Inputs Components
+ */
+export declare type BaseRadioFieldProps<V> = BaseRadioFieldHTMLAttributes & ReformEvents<V> & {
+    modelValue: V;
+    render: () => void;
+};
+
+/**
+ * A base select field component that can be used to create custom select input components connected to the form state.
+ *
+ * To use it with with a basic { value, label } pair, you can use the following props:
+ * ```tsx
+ * <BaseSelectField
+ *     name="mySelectId"
+ *     modelValues={[ null, "1", "2" ]}
+ *     toOptionValue={ modelValue => modelValue ?? "" }
+ *     toOptionContent={ modelValue => modelValue == null ? "Select..." : `Option ${modelValue}` }
+ *     toModelValue={ optionValue => optionValue === "" ? null : optionValue }
+ *     render={ myRenderFunction } />
+ * ```
+ * @category Base Inputs Components
+ */
+export declare function BaseSelectField<Value = string>(props: BaseSelectFieldProps<Value | null>): JSX_3.Element;
+
+/**
+ * @ignore
+ */
+export declare type BaseSelectFieldHTMLAttributes = (Omit<SelectHTMLAttributes<HTMLSelectElement>, 'name' | 'value' | 'defaultValue' | 'defaultChecked' | 'suppressContentEditableWarning' | 'suppressHydrationWarning' | 'contentEditable' | 'contextMenu' | 'hidden' | 'is' | 'autoComplete' | 'form' | 'multiple' | keyof DOMAttributes<HTMLSelectElement>> & {
+    name: string;
+});
+
+/**
+ * @category Base Inputs Components
+ */
+export declare type BaseSelectFieldProps<V> = BaseSelectFieldHTMLAttributes & ReformEvents<V> & {
+    modelValues: V[];
+    toOptionValue: (modelValue: V) => string;
+    toOptionContent: (modelValue: V) => string;
+    toModelValue: (optionValue: string) => V;
+    render: () => void;
+};
+
+/**
+ * A base text area component that can be used to create custom text area input components connected to the form state.
+ * @category Base Inputs Components
+ */
+export declare function BaseTextAreaField(props: BaseTextAreaFieldProps): JSX_3.Element;
+
+/**
+ * @ignore
+ */
+export declare type BaseTextAreaFieldHTMLAttributes = (Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'name' | 'value' | 'defaultValue' | 'defaultChecked' | 'suppressContentEditableWarning' | 'suppressHydrationWarning' | 'contentEditable' | 'contextMenu' | 'hidden' | 'is' | 'autoComplete' | 'dirName' | 'form' | keyof DOMAttributes<HTMLTextAreaElement>> & {
+    name: string;
+});
+
+/**
+ * @category Base Inputs Components
+ */
+export declare type BaseTextAreaFieldProps = BaseTextAreaFieldHTMLAttributes & ReformEvents<string> & {
+    render: () => void;
+};
+
+/**
+ * A base text field component that can be used to create custom text input components connected to the form state. It handles change and blur events,
+ * converts between the input value and the model value using the provided `toModelValue` and `toTextValue` functions, and calls the provided `render`
+ * function to update the form state when the value changes. It also supports an `acceptInputValue` function to validate the input value on each change
+ * and a `formatDisplayedValue` function to format the displayed value while editing.
+ * @category Base Inputs Components
+ */
+export declare function BaseTextField<Value = string>(props: BaseTextFieldProps<Value>): JSX_3.Element;
+
+/**
+ * @ignore
+ */
+export declare type BaseTextFieldHTMLAttributes = Omit<InputAttributes<"text" | "search" | "number" | "date" | "email" | "password" | "tel" | "time">, 'accept' | 'alt' | 'capture' | 'height' | 'multiple' | 'src' | 'step' | 'width'>;
+
+/**
+ * @category Base Inputs Components
+ */
+export declare type BaseTextFieldProps<V> = BaseTextFieldHTMLAttributes & ReformEvents<V> & {
+    toModelValue?: (value: string) => V | null;
+    toTextValue?: (value: V | null) => string;
+    acceptInputValue?: (value: string) => boolean;
+    formatDisplayedValue?: (value: string) => string;
+    formatOnEdit?: boolean;
+    render: () => void;
+};
+
+/**
+ * Basic implementation of MessageProvider for localized validation messages.
+ * @category Localization
+ */
+export declare class BasicMessageProvider implements MessageProvider {
+    readonly locale: string;
+    private readonly numberFormat;
+    private readonly dateFormat;
+    private readonly listFormat;
+    private readonly pluralRules;
+    /**
+     * Map of message codes to message functions.
+     */
+    readonly messages: Map<string, MessageFunction>;
+    /**
+     * Creates a new BasicMessageProvider for a given locale and message entries.
+     * @param locale - The locale identifier.
+     * @param entries - Optional array of [code, message function] pairs.
+     */
+    constructor(locale: string, entries?: (readonly [string, MessageFunction])[]);
+    /**
+     * @inheritdoc
+     */
+    getMessage(context: InternalValidationContext<unknown>, code: string, constraint: any, message: ConstraintMessage | undefined, level: Level): ConstraintMessage;
+}
+
+/**
+ * Decorator for applying validation rules to a boolean field.
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠boolean({ required: true, oneOf: [[true], "Must be an adult"] })
+ *     adult: boolean | null = null
+ * }
+ * const form = useForm(Person, ...)
+ *
+ * // the boolean decorator can also be used as a function to allow standalone validation:
+ * Yop.validate(false, boolean({ oneOf: [true] })) // error: "Must be one of: true"
+ * ```
+ * @template Value - The type of the boolean value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The boolean constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export declare function boolean<Value extends BooleanValue, Parent>(constraints?: BooleanConstraints<Value, Parent>, groups?: Groups<BooleanConstraints<Value, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Interface for boolean field constraints, combining common, oneOf, and test constraints.
+ * @template Value - The type of the boolean value.
+ * @template Parent - The type of the parent object.
+ * @see {@link CommonConstraints}
+ * @see {@link OneOfConstraint}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export declare interface BooleanConstraints<Value extends BooleanValue, Parent> extends CommonConstraints<Value, Parent>, OneOfConstraint<Value, Parent>, TestConstraint<Value, Parent> {
+}
+
+/**
+ * Type for a boolean value, which can be true, false, null, or undefined.
+ * @ignore
+ */
+export declare type BooleanValue = boolean | null | undefined;
+
+/**
+ * Type for a class constructor of a given type.
+ * @template Type - The type of the class instance.
+ * @ignore
+ */
+export declare type ClassConstructor<Type> = new (...args: any) => NonNullable<Type>;
+
+/**
+ * Type for a class field decorator function.
+ * @template Value - The type of the field value.
+ * @template Parent - The type of the parent object.
+ * @ignore
+ */
+export declare type ClassFieldDecorator<Value, Parent = unknown> = (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Deep clones a value, handling arrays, objects, dates, maps, sets, and files.
+ * @template T - The value type.
+ * @param value - The value to clone.
+ * @param cloned - Optional map of already cloned values.
+ * @returns The cloned value.
+ * @category Utilities
+ */
+export declare function clone<T>(value: T, cloned?: Map<any, any>): T;
+
+/**
+ * Common validation constraints for a value, used in decorators and validation logic.
+ * @template Value - The type of the value being validated.
+ * @template Parent - The type of the parent object.
+ * @category Shared Constraints
+ */
+export declare interface CommonConstraints<Value, Parent = unknown> {
+    /**
+     * If `true`, the validation of the decorated element is skipped.
+     */
+    ignored?: Constraint<Value | null | undefined, boolean, Parent>;
+    /**
+     * If `true`, the property must be present in the parent object (ie: `"prop" in obj` is true).
+     */
+    exists?: Constraint<Value | null | undefined, boolean, Parent>;
+    /**
+     * If `true`, the value must not be `undefined`.
+     */
+    defined?: Constraint<Value | null | undefined, boolean, Parent>;
+    /**
+     * If `true`, the value must not be `null`.
+     */
+    notnull?: Constraint<Value | null | undefined, boolean, Parent>;
+    /**
+     * If `true`, the value must not be `undefined` or `null`.
+     */
+    required?: Constraint<Value | null | undefined, boolean, Parent>;
+}
+
+/**
+ * A constraint can be defined as a direct value, a tuple with value, message and level, or a function returning
+ * either of those.
+ * @category Shared Constraints
+ */
+export declare type Constraint<Value, ConstraintType, Parent = unknown> = ConstraintValue<ConstraintType> | ConstraintFunction<Value, ConstraintType, Parent>;
+
+/**
+ * Type representing a constraint function that returns a constraint value.
+ * @template Value - The type of the value being validated.
+ * @template ConstraintType - The type of the constraint value.
+ * @template Parent - The type of the parent object.
+ * @category Shared Constraints
+ */
+export declare type ConstraintFunction<Value, ConstraintType, Parent = unknown> = ((context: ValidationContext<Value, Parent>) => ConstraintValue<ConstraintType> | undefined);
+
+/**
+ * Type representing a constraint message, which can be a direct string or JSX element.
+ * @category Shared Constraints
+ */
+export declare type ConstraintMessage = string | JSX_2.Element;
+
+/**
+ * Interface for settings used when resolving constraints at a specific path.
+ * @ignore
+ */
+export declare interface ConstraintsAtSettings extends ValidationSettings {
+    unsafeMetadata?: boolean;
+}
+
+/**
+ * Type representing a constraint value, which can be a direct value or a tuple containing the value, an optional message, and an optional level.
+ * This allows for flexible constraint definitions that can include custom error messages and severity levels.
+ * @template ConstraintType - The type of the constraint value.
+ * @category Shared Constraints
+ */
+export declare type ConstraintValue<ConstraintType> = ConstraintType | readonly [ConstraintType, ConstraintMessage, Level?];
+
+/**
+ * Type for a constructor of a given type, including primitive constructors.
+ * @template Type - The type to construct.
+ * @ignore
+ */
+export declare type Constructor<Type = unknown> = Type extends unknown ? ClassConstructor<Type> | StringConstructor | BooleanConstructor | NumberConstructor : [
+Type
+] extends [string | null | undefined] ? StringConstructor : [
+Type
+] extends [boolean | null | undefined] ? BooleanConstructor : [
+Type
+] extends [number | null | undefined] ? NumberConstructor : ClassConstructor<Type>;
+
+/**
+ * Extracts the parent type from a CommonConstraints type.
+ * @ignore
+ */
+export declare type ContraintsParent<Contraints> = Contraints extends CommonConstraints<infer _Value, infer Parent> ? Parent : never;
+
+/**
+ * Extracts the value type from a CommonConstraints type.
+ * @ignore
+ */
+export declare type ContraintsValue<Contraints> = Contraints extends CommonConstraints<infer Value, infer _Parent> ? Value : never;
+
+/**
+ * Decorator for applying validation rules to a Date field.
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠date({ required: true, min: new Date("1900-01-01") })
+ *     dateOfBirth: Date | null = null
+ * }
+ * const form = useForm(Person, ...)
+ *
+ * // the date decorator can also be used as a function to allow standalone validation:
+ * Yop.validate(null, date({ required: true })) // error: "Required field"
+ * ```
+ * @template Value - The type of the date value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The date constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export declare function date<Value extends DateValue, Parent>(constraints?: DateConstraints<Value, Parent>, groups?: Groups<DateConstraints<Value, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Interface for date field constraints, combining common, min/max, oneOf, and test constraints.
+ * @template Value - The type of the date value.
+ * @template Parent - The type of the parent object.
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link OneOfConstraint}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export declare interface DateConstraints<Value extends DateValue, Parent> extends CommonConstraints<Value, Parent>, MinMaxConstraints<Value, Date, Parent>, OneOfConstraint<Value, Parent>, TestConstraint<Value, Parent> {
+}
+
+/**
+ * Type for a date value, which can be a Date object, null, or undefined.
+ * @ignore
+ */
+export declare type DateValue = Date | null | undefined;
+
+/**
+ * Defines a lazily-evaluated property on an object.
+ * @template T - The object type.
+ * @param o - The object.
+ * @param name - The property name.
+ * @param get - The getter function.
+ * @ignore
+ */
+export declare function defineLazyProperty<T>(o: T, name: PropertyKey, get: ((_this: T) => unknown)): void;
+
+/**
+ * Type for a diff result between two values.
+ * @template A - The first value type.
+ * @template B - The second value type.
+ * @category Utilities
+ */
+export declare type Diff<A = any, B = any> = {
+    /**
+     * The first value in the diff comparison.
+     */
+    a: A;
+    /**
+     * The second value in the diff comparison.
+     */
+    b: B;
+    /**
+     * The diff tree representing differences between the two values. The tree is a nested object where keys are path segments and values are
+     * either further nested objects or empty objects indicating a difference at that path. If a path is not present in the tree, it means
+     * the values are equal at that path. When `equal` is true, the tree is an empty object: `{}`.
+     */
+    tree: {
+        [key: string | number]: any;
+    };
+    /**
+     * Indicates whether the two values are equal.
+     */
+    equal: boolean;
+};
+
+/**
+ * Computes the diff between two values, returning a diff tree and equality flag.
+ * @template A - The first value type.
+ * @template B - The second value type.
+ * @param a - The first value.
+ * @param b - The second value.
+ * @returns The diff result.
+ * @category Utilities
+ */
+export declare function diff<A = any, B = any>(a: A, b: B): Diff<A, B>;
+
+/**
+ * Checks if two values differ at a given path, using a diff tree.
+ * @param diff - The diff result.
+ * @param path - The path to check.
+ * @returns True if values differ at the path, false otherwise.
+ * @category Utilities
+ */
+export declare function differs(diff: Diff, path: Path): boolean;
+
+/**
+ * Decorator for applying validation rules to an email field. Emails are validated against a standard email regex pattern (RFC 5322 compliant).
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠email({ required: true, formatError: "Invalid email address" })
+ *     email: string | null = null
+ * }
+ * const form = useForm(Person, ...)
+ *
+ * // the email decorator can also be used as a function to allow standalone validation:
+ * Yop.validate(null, email({ required: true })) // error: "Required field"
+ * ```
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The email constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export declare function email<Value extends StringValue, Parent>(constraints?: EmailConstraints<Value, Parent>, groups?: Groups<EmailConstraints<Value, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Interface for email field constraints, extending string constraints but omitting 'match'.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @property formatError - Custom error message for invalid email format.
+ * @see {@link StringConstraints}
+ * @category Property Decorators
+ */
+export declare interface EmailConstraints<Value extends StringValue, Parent> extends Omit<StringConstraints<Value, Parent>, "match"> {
+    /**
+     * Custom error message for invalid email format. `formatError` can be a {@link Message} or a function that returns a {@link Message}.
+     * @see {@link emailRegex}
+     */
+    formatError?: Message<Value, Parent>;
+}
+
+/**
+ * Regular expression for validating email addresses (RFC 5322 compliant).
+ * @ignore
+ */
+export declare const emailRegex: RegExp;
+
+/**
+ * Checks deep equality between two values, optionally ignoring a path.
+ * @param a - The first value.
+ * @param b - The second value.
+ * @param ignoredPath - Optional path to ignore.
+ * @returns True if equal, false otherwise.
+ * @category Utilities
+ */
+export declare function equal(a: any, b: any, ignoredPath?: string | Path): boolean;
+
+/**
+ * Creates a class field decorator that assigns or modifies field constraints.
+ * @template Parent - The type of the parent object.
+ * @template Value - The type of the field value.
+ * @param properties - An object or function to assign/modify field constraints.
+ * @param reset - If true, resets the field constraints before applying properties.
+ * @returns A class field decorator function.
+ * @ignore
+ */
+export declare function fieldDecorator<Parent, Value>(properties: object | ((field: InternalCommonConstraints) => void), reset?: boolean): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Represents the state of a form field, including value, validation, and metadata.
+ * @template Value - The type of the field value.
+ * @template MinMax - The type for min/max constraints.
+ * @template Root - The type of the root form values.
+ * @category Form Management
+ */
+export declare type FieldState<Value, MinMax, Root = any> = {
+    /** The current value of the field. */
+    value: Value | undefined;
+    /** Whether the field has been touched. */
+    touched: boolean;
+    /** The validation status of the field, if any. See {@link ValidationStatus} for details. */
+    status?: ValidationStatus;
+    /** The form manager instance. See {@link FormManager} for details. */
+    form: FormManager<Root>;
+    /** Function to trigger a re-render of the component that called {@link useFormField} to get this field state. */
+    render: () => void;
+    /** The resolved constraints for the field, if any. See {@link ResolvedConstraints} for details. */
+    constraints?: ResolvedConstraints<MinMax>;
+};
+
+/**
+ * Creates a field validation decorator with the specified kind, constraints, groups, and validator.
+ * @template Constraints - The type of the field constraints.
+ * @template Value - The type of the field value.
+ * @template Parent - The type of the parent object.
+ * @param kind - The kind of the field (e.g., 'string', 'number').
+ * @param constraints - The field constraints to apply.
+ * @param groups - Optional groups of constraints.
+ * @param validator - The validation function for the field.
+ * @param isMinMaxType - Optional function to check min/max type.
+ * @param traverse - Optional traverser function for the field.
+ * @returns A class field decorator function with validation.
+ * @ignore
+ */
+export declare function fieldValidationDecorator<Constraints extends CommonConstraints<any, any>, Value = ContraintsValue<Constraints>, Parent = ContraintsParent<Constraints>>(kind: string, constraints: Constraints, groups: Groups<Constraints> | undefined, validator: Validator<Constraints>, isMinMaxType?: (value: any) => boolean, traverse?: Traverser<Constraints>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Decorator for applying validation rules to a File field.
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠file({ required: true, min: [1024, "Picture size must be at least 1KB"] })
+ *     profilePicture: File | null = null
+ * }
+ * const form = useForm(Person, ...)
+ *
+ * // the file decorator can also be used as a function to allow standalone validation:
+ * Yop.validate(null, file({ required: true })) // error: "Required field"
+ * ```
+ * @template Value - The type of the file value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The file constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export declare function file<Value extends FileValue, Parent>(constraints?: FileConstraints<Value, Parent>, groups?: Groups<FileConstraints<Value, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Interface for file field constraints, combining common, min/max, and test constraints.
+ * @template Value - The type of the file value.
+ * @template Parent - The type of the parent object.
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export declare interface FileConstraints<Value extends FileValue, Parent> extends CommonConstraints<Value, Parent>, MinMaxConstraints<Value, number, Parent>, TestConstraint<Value, Parent> {
+}
+
+/**
+ * Type for a file value, which can be a File object, null, or undefined.
+ * @ignore
+ */
+export declare type FileValue = File | null | undefined;
+
+/**
+ * React component for rendering an HTML form with context, error display, and automatic form disabling. All children of
+ * this component will have access to the form manager via context, and they will be enclosed in an HTML `fieldset` that is disabled according to the
+ * `disabled` prop. If there are any validation errors, and if the debug option `displayFormErrors` is enabled (see {@link Reform.displayFormErrors}),
+ * they will be displayed in a formatted block below the form.
+ *
+ * Example usage:
+ * ```tsx
+ * const form = useForm(MyFormModel, onSubmit)
+ * return (
+ *     <Form form={form} autoComplete="off" noValidate disabled={form.submitting}>
+ *        // form fields here, using form context
+ *        <button type="submit">Submit</button>
+ *     </Form>
+ * )
+ * ```
+ *
+ * @param props - The Form props.
+ * @returns The rendered Form component.
+ * @category Form Management
+ */
+export declare function Form(props: FormProps): JSX_3.Element;
+
+/**
+ * Configuration options for the useForm hook.
+ * @template T - The type of the form values.
+ * @category Form Management
+ */
+export declare type FormConfig<T extends object | any[] | null | undefined> = {
+    /**
+     * Initial values for the form. Can be an object, a function returning an object, or a function returning a promise that
+     * resolves to an object. Initial values are cloned and stored internally the first time they are neither `null` nor `undefined`.
+     * If a function is provided, it will be called on the first render and whenever the config changes, allowing for dynamic
+     * initial values. If the function returns a promise, the form will be in a pending state until the promise resolves, at
+     * which point the initial values will be set and the form will re-render.
+     *
+     * @see {@link FormManager.initialValuesPending}
+     * @see {@link FormConfig.initialValuesConverter}
+     */
+    readonly initialValues?: T | (() => T) | (() => Promise<T>) | null;
+    /**
+     * Converter function for initial values. This function is called with the initial values whenever they become neither
+     * `null` nor `undefined`. It allows for transformation or normalization of the initial values before they are set in the form.
+     * @param values - The initial values.
+     * @returns The transformed initial values.
+     */
+    readonly initialValuesConverter?: (values: T) => T;
+    /**
+     * The validation schema for the form. This can be a schema object created with the `instance` or `array` decorator.
+     * It defines the rules for validating the form values.
+     *
+     * Example usage:
+     * ```tsx
+     * const form = useForm({
+     *     initialValues: new Person(),
+     *     validationSchema: instance({ of: Person, required: true }),
+     * })
+     * ```
+     */
+    readonly validationSchema?: ((_: unknown, context: ClassFieldDecoratorContext<unknown, T>) => void);
+    /**
+     * Path or paths to validate. This can be a single path string or an array of path strings. If specified, only the values
+     * at these paths will be validated. If not specified, the entire form values will be validated.
+     */
+    readonly validationPath?: string | string[];
+    /**
+     * Validation groups to use during validation. This can be a single group or an array of groups. If specified, the validation
+     * rules associated with these groups will be applied. If not specified, only the validation rules of the default group will
+     * be applied.
+     *
+     * For example:
+     * ```tsx
+     * // will apply validation rules of "group1":
+     * validationGroups: "group1"
+     * // will apply validation rules of "group1" and "group2":
+     * validationGroups: ["group1", "group2"]
+     * // will apply validation rules of the default group and "group2":
+     * validationGroups: [undefined, "group2"]
+     * ```
+     */
+    readonly validationGroups?: Group;
+    /**
+     * Function to determine if a path should be ignored during validation. This function is called with the path being
+     * validated and the form manager instance. If it returns `true`, the path will be ignored and no validation will be
+     * performed for it.
+     * @param path - The path being validated.
+     * @param form - The form manager instance.
+     * @returns `true` if the path should be ignored, `false` otherwise.
+     */
+    readonly ignore?: (path: Path, form: FormManager<T>) => boolean;
+    /**
+     * Function to determine if the form can be submitted. This function is called with the form manager instance when a submit
+     * is attempted. If it returns `true`, the form will be submitted and the `onSubmit` callback will be called. If it returns
+     * `false`, the submit will be aborted and the `onSubmit` callback will not be called.
+     * @param form - The form manager instance.
+     * @returns `true` if the form can be submitted, `false` otherwise.
+     */
+    readonly submitGuard?: (form: FormManager<T>) => boolean;
+    /**
+     * Callback for form submission. This function is called with the form manager instance when the form is submitted and the
+     * `submitGuard` (if provided) returns `true`. It is responsible for handling the form submission logic, such as sending
+     * the form values to a server or updating application state. The {@link FormManager.submitting} is automatically set to
+     * `true` while this function is called. It is the responsibility of the caller to set it back to `false` when the
+     * submission process is complete (see {@link FormManager.setSubmitting}).
+     *
+     * Example usage:
+     * ```tsx
+     * const form = useForm({
+     *     initialValues: new Person(),
+     *     validationSchema: instance({ of: Person, required: true }),
+     *     onSubmit: (form) => {
+     *         console.log("Form submitted with values:", form.values)
+     *         try {
+     *             // perform submission logic here
+     *         }
+     *         finally {
+     *             form.setSubmitting(false)
+     *         }
+     *     }
+     * })
+     * ```
+     * @param form - The form manager instance.
+     * @returns void
+     */
+    readonly onSubmit?: (form: FormManager<T>) => void;
+    /**
+     * Whether to dispatch events for observer propagation. If `true`, when a value changes, an event will be dispatched that can
+     * be listened to by observers to react to value changes. Default is `true`.
+     */
+    readonly dispatchEvent?: boolean;
+};
+
+/**
+ * React context for providing a FormManager instance to descendant components.
+ * @ignore
+ */
+export declare const FormContext: default_2.Context<FormManager<unknown> | null>;
+
+/**
+ * Interface for a form manager, providing value management, validation, and event APIs.
+ * @category Form Management
+ */
+export declare interface FormManager<T> extends ValidationForm {
+    /**
+     * Renders the form, causing any changes to be reflected in the UI.
+     */
+    render(): void;
+    /**
+     * Sets the submitting state of the form. Submitting state is automatically set to `true` when the form is submitted, and
+     * should be reset to `false` when submission is complete.
+     * @param submitting - Whether the form is submitting.
+     */
+    setSubmitting(submitting: boolean): void;
+    /**
+     * The initial values of the form, as provided in the form config. These values are not modified by the form manager, and
+     * represent the original state of the form.
+     */
+    readonly initialValues: T | null | undefined;
+    /**
+     * Used when initialValues is provided as a promise. Indicates whether the promise is still pending.
+     */
+    readonly initialValuesPending: boolean;
+    /**
+     * The current values of the form. These values are managed by the form manager and should be considered the source of truth
+     * for the form state.
+     */
+    readonly values: T;
+    /**
+     * Sets the value of a form field.
+     * @param path - The path to the field.
+     * @param value - The value to set.
+     * @param options - Options for setting the value. See {@link SetValueOptions}.
+     * @returns The result of the set operation, or undefined if the path was invalid. See {@link SetResult}.
+     */
+    setValue(path: string | Path, value: unknown, options?: SetValueOptions): SetResult;
+    /**
+     * Validates the entire form.
+     * @param touchedOnly - Whether to validate only touched fields.
+     * @param ignore - A function to determine if a path should be ignored during validation.
+     */
+    validate(touchedOnly?: boolean, ignore?: (path: Path) => boolean): Map<string, ValidationStatus>;
+    /**
+     * Validates a specific field located at a given path in the form.
+     * @param path - The path to the field.
+     * @param touchedOnly - Whether to validate only touched fields.
+     * @param skipAsync - Whether to skip asynchronous validation.
+     */
+    validateAt(path: string | Path, touchedOnly?: boolean, skipAsync?: boolean): {
+        changed: boolean;
+        statuses: Map<string, ValidationStatus>;
+    };
+    /**
+     * Updates the asynchronous validation status of a specific field.
+     * @param path - The path to the field.
+     */
+    updateAsyncStatus(path: string | Path): void;
+    /**
+     * Scrolls to the first field with a validation error, if any. This is typically called after form submission if there
+     * are validation errors, to bring the user's attention to the first error. The implementation will scroll to an HTML with
+     * an id set to the path of the field with the error, so form fields should have their id set accordingly for this to work.
+     */
+    scrollToFirstError(): void;
+    /**
+     * Retrieves the constraints for a specific field.
+     * @param path - The path to the field.
+     * @param unsafeMetadata - Whether to include unsafe field metadata. If `true`, the resolved constraints will be of type
+     *      {@link UnsafeResolvedConstraints}, which enables modification of the field constraints stored in the class metadata.
+     *      This can be useful for advanced use cases, but should be used with caution.
+     * @return The resolved constraints for the field, or undefined if there are no constraints. See {@link ResolvedConstraints}.
+     */
+    constraintsAt<MinMax = unknown>(path: string | Path, unsafeMetadata?: boolean): ResolvedConstraints<MinMax> | undefined;
+    /**
+     * Handler for form submission. This should be called in the onSubmit handler of the form element. It will prevent the default
+     * form submission behavior,
+     * @param e - The form submission event.
+     */
+    submit(e: FormEvent<HTMLFormElement>): void;
+    /**
+     * Retrieves an array helper for a specific field. The array helper provides methods for manipulating array fields, such
+     * as appending, inserting, and removing elements, with automatic touch, validation, and rendering.
+     * @param path - The path to the array field.
+     * @return An ArrayHelper instance for the specified path, or undefined if the field is not an array.
+     */
+    array<T = any>(path: string): ArrayHelper<T> | undefined;
+    /**
+     * Adds an event listener for reform events of type {@link ReformSetValueEvent}.
+     * @param listener - The event listener to add.
+     */
+    addReformEventListener(listener: EventListener): void;
+    /**
+     * Removes an event listener for reform events of type {@link ReformSetValueEvent}.
+     * @param listener - The event listener to remove.
+     */
+    removeReformEventListener(listener: EventListener): void;
+}
+
+/**
+ * Props for the Form component.
+ * @property form - The form manager instance.
+ * @property disabled - Whether the form is disabled.
+ * @category Form Management
+ */
+export declare interface FormProps extends Omit<FormHTMLAttributes<HTMLFormElement>, "onSubmit"> {
+    /** The form manager instance. */
+    form: FormManager<unknown>;
+    /** Whether the form is disabled. */
+    disabled?: boolean;
+}
+
+/**
+ * Retrieves a value from an object or array using a string or parsed path.
+ * @param value - The root object or array.
+ * @param path - The path string or array.
+ * @param cache - Optional cache for parsed paths.
+ * @returns The value at the path, or undefined if not found.
+ * @category Utilities
+ */
+export declare function get<T = any>(value: unknown, path: string | Path, cache?: Map<string, Path>): T | undefined;
+
+/**
+ * Retrieves the class constructor from validation metadata, handling array and instance kinds.
+ * @template T - The type of the class instance.
+ * @param metadata - The validation metadata object.
+ * @returns The class constructor, if found.
+ * @ignore
+ */
+export declare function getClassConstructor<T>(metadata: any): ClassConstructor<T> | undefined;
+
+/**
+ * Retrieves the validation metadata for a given class constructor.
+ * @template T - The type of the class instance.
+ * @param model - The class constructor.
+ * @returns The common constraints metadata, if any.
+ * @ignore
+ */
+export declare function getMetadata<T>(model: ClassConstructor<T>): CommonConstraints<any, T> | undefined;
+
+/**
+ * Retrieves the field constraints metadata for all fields of a class constructor.
+ * @template T - The type of the class instance.
+ * @param model - The class constructor.
+ * @returns An object mapping field names to their constraints, if any.
+ * @ignore
+ */
+export declare function getMetadataFields<T>(model: ClassConstructor<T>): { [K in keyof T]: CommonConstraints<any, T>; } | undefined;
+
+/**
+ * Retrieves field metadata from a class field decorator.
+ * @template Value - The type of the field value.
+ * @template Parent - The type of the parent object.
+ * @param decorator - The class field decorator function.
+ * @returns The field constraints metadata for a placeholder field.
+ * @ignore
+ */
+export declare function getMetadataFromDecorator<Value, Parent>(decorator: ClassFieldDecorator<Value, Parent>): InternalCommonConstraints | undefined;
+
+/**
+ * Retrieves the kind of a validation decorator from a value.
+ * @param value - The value to inspect.
+ * @returns The decorator kind, if present.
+ * @ignore
+ */
+export declare function getValidationDecoratorKind(value: any): string | undefined;
+
+/**
+ * Type representing the validation group or groups being currently validated. `undefined` means the default group.
+ * @category Validation Management
+ */
+export declare type Group = string | ((string | undefined)[]);
+
+/**
+ * Type for a map of group names to constraints.
+ * @template Constraints - The type of the constraints.
+ * @ignore
+ */
+export declare type Groups<Constraints> = {
+    [group: string]: Constraints;
+};
+
+/**
+ * The HTMLInputTypeAttribute type is a union of string literals that represent the valid values for the "type" attribute of an HTML input element
+ * It includes common input types such as "text", "password", "email", etc., as well as a catch-all for any other string value that may be used as a
+ * custom input type. This allows for flexibility while still providing type safety for known input types.
+ * @ignore
+ */
+declare type HTMLInputTypeAttribute = 'button' | 'checkbox' | 'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'month' | 'number' | 'password' | 'radio' | 'range' | 'reset' | 'search' | 'submit' | 'tel' | 'text' | 'time' | 'url' | 'week' | (string & {});
+
+/**
+ * Class decorator to register a class with a unique identifier in the Yop registry. It can be used when you need to reference
+ * classes by an identifier to prevent circular references.
+ *
+ * Example usage:
+ * ```tsx
+ * ＠id("Person")
+ * class Person {
+ *
+ *    ＠instance({ of: "Person" }) // circular reference to itself using the class id
+ *    friend: Person | null = null
+ *
+ *    ＠array({ of: "Person" }) // circular reference to itself using the class id
+ *    friends: Person[] | null = null
+ * }
+ * ```
+ *
+ * @template Type - The type of the class instance.
+ * @template Class - The constructor type of the class.
+ * @param id - The unique identifier for the class.
+ * @returns A class decorator function that registers the class in the Yop registry.
+ * @see {@link InstanceConstraints}
+ * @see {@link ArrayConstraints}
+ * @category Class Decorators
+ */
+export declare function id<Type extends object, Class extends Constructor<Type>>(id: string): (target: Class, _: ClassDecoratorContext<Class>) => void;
+
+/**
+ * Field decorator to mark a field as ignored for validation.
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠string({ required: true, match: /^[A-Za-z]+$/ })
+ *     name: string | null = null
+ * }
+ * class Anonymous extends Person {
+ *     ＠ignored() // ignore all validation constraints on `name`
+ *     override name: string | null = null
+ * }
+ * ```
+ *
+ * @template Parent - The type of the parent object.
+ * @param ignored - The constraint or boolean indicating if the field should be ignored (default: true).
+ * @param groups - Optional groups with their own ignored constraints.
+ * @returns A field decorator function that marks a field as ignored for validation.
+ * @category Property Decorators
+ */
+export declare function ignored<Parent>(ignored?: Constraint<any, boolean, Parent>, groups?: Groups<Constraint<any, boolean, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, any>) => void;
+
+/**
+ * Initializes and returns the internal class constraints for a given decorator metadata object.
+ * @param decoratorMetadata - The metadata object from a class decorator.
+ * @returns The initialized internal class constraints.
+ * @ignore
+ */
+export declare function initClassConstraints(decoratorMetadata: DecoratorMetadata): InternalClassConstraints<any>;
+
+/**
+ * The InputAttributes type is a utility type that takes an InputType parameter, which extends the HTMLInputTypeAttribute type. It uses the Omit utility
+ * type to exclude certain properties from the InputHTMLAttributes type, such as 'name', 'type', 'value', 'checked', and others that are not relevant
+ * for the input component. It then adds back the 'name' property as a required string and the 'type' property as an optional InputType. This allows for
+ * creating a more specific set of attributes for input components while still maintaining flexibility for different input types.
+ * @ignore
+ */
+export declare type InputAttributes<InputType extends HTMLInputTypeAttribute> = (Omit<InputHTMLAttributes<HTMLInputElement>, 'name' | 'type' | 'value' | 'checked' | 'defaultValue' | 'defaultChecked' | 'suppressContentEditableWarning' | 'suppressHydrationWarning' | 'contentEditable' | 'contextMenu' | 'hidden' | 'is' | 'alt' | 'form' | 'formaction' | 'formenctype' | 'formmethod' | 'formnovalidate' | 'formtarget' | 'pattern' | 'src' | keyof DOMAttributes<HTMLInputElement>> & {
+    name: string;
+    type?: InputType;
+});
+
+/**
+ * @ignore
+ */
+export declare interface InputSelection {
+    start: number | null;
+    end: number | null;
+    direction?: "forward" | "backward" | "none";
+}
+
+/**
+ * Decorator for validating a field value as an instance of a specified class. The `of` property must be set to a custom
+ * class constructor, not a built-in object type like String or Date.
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠instance({ of: Dog, required: true })
+ *     dog: Dog | null = null
+ * }
+ * const form = useForm(Person, ...)
+ *
+ * // the instance decorator can also be used as a function to allow standalone validation:
+ * Yop.validate(new Person(), instance({ of: Person })) // error: dog is a "Required field"
+ * ```
+ * @template Value - The type of the instance value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The instance constraints.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator that stores the instance constraints and validation function in the class metadata.
+ * @category Property Decorators
+ */
+export declare function instance<Value extends InstanceValue, Parent>(constraints?: InstanceConstraints<Value, Parent>, groups?: Groups<InstanceConstraints<Value, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Constraints for validating an instance of a class. Inherits common and test constraints.
+ * @template Value - The type of the instance value.
+ * @template Parent - The type of the parent object.
+ * @property of - A class constructor, a function returning a constructor, or a class id to validate the instance against.
+ * @see {@link id}
+ * @see {@link CommonConstraints}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export declare interface InstanceConstraints<Value extends InstanceValue, Parent> extends CommonConstraints<Value, Parent>, TestConstraint<Value, Parent> {
+    /**
+     * A class constructor, a function returning a constructor, or a class id (see {@link id}) to validate the instance against.
+     */
+    of: ClassConstructor<NoInfer<Value>> | (() => ClassConstructor<NoInfer<Value>>) | string;
+}
+
+/**
+ * The kind string used to identify instance constraints.
+ * @ignore
+ */
+export declare const instanceKind = "instance";
+
+/**
+ * Utility type to extract the instance type from a constructor.
+ * @template Class - The constructor type.
+ * @category Class Decorators
+ */
+declare type InstanceType_2<Class> = Class extends Constructor<infer Type> ? Type : never;
+export { InstanceType_2 as InstanceType }
+
+/**
+ * Type for values that can be validated as instances (objects, null, or undefined).
+ * @ignore
+ */
+export declare type InstanceValue = object | null | undefined;
+
+/**
+ * Internal constraints for a class, including test and field constraints.
+ * @template Class - The type of the class.
+ * @ignore
+ */
+export declare interface InternalClassConstraints<Class = any> extends InternalConstraints {
+    /**
+     * Optional test constraint function for the class.
+     */
+    test?: TestConstraintFunction<Class>;
+    /**
+     * Optional map of field names to their internal constraints.
+     */
+    fields?: {
+        [name: string]: InternalCommonConstraints;
+    };
+}
+
+/**
+ * Internal constraints that include both common and internal constraint logic.
+ * @ignore
+ */
+export declare interface InternalCommonConstraints extends CommonConstraints<any, any>, InternalConstraints {
+}
+
+/**
+ * Used internally.
+ * @ignore
+ */
+export declare interface InternalConstraints {
+    /**
+     * The kind of the decorated value (eg: `string`, `number`, etc.)
+     */
+    kind: string;
+    /**
+     * The method that validates the decorated value.
+     */
+    validate: Validator<this>;
+    /**
+     * The method that returns the constraints and value of a nested field.
+     */
+    traverse?: Traverser<this>;
+    /**
+     * Validation groups with specific constraints. If specified, the given constraints will only be validated if at least one
+     * of the groups is active in the validation context.
+     */
+    groups?: Groups<this>;
+}
+
+/**
+ * Implementation of the FormManager interface, providing value management, validation, eventing, and array helpers.
+ * @ignore
+ */
+export declare class InternalFormManager<T extends object | null | undefined> implements FormManager<T> {
+    readonly render: () => void;
+    private _config;
+    private yop;
+    private pathCache;
+    private _initialValues;
+    private _initialValuesPending;
+    private _values;
+    private _statuses;
+    private touched;
+    private _submitting;
+    private _submitted;
+    private eventTarget;
+    htmlForm?: HTMLFormElement;
+    constructor(render: () => void);
+    addReformEventListener(listener: EventListener): void;
+    removeReformEventListener(listener: EventListener): void;
+    get initialValuesPending(): boolean;
+    get submitted(): boolean;
+    get submitting(): boolean;
+    get config(): FormConfig<T>;
+    get store(): Map<string, any>;
+    set initialValuesPending(pending: boolean);
+    setSubmitting(submitting: boolean): void;
+    commitInitialValues(): void;
+    onRender(config: FormConfig<T>): void;
+    get initialValues(): T | null | undefined;
+    get values(): T;
+    getValue<V = any>(path: string | Path): V | undefined;
+    setValue(path: string | Path, value: unknown, options?: SetValueOptions): SetResult;
+    isDirty(path?: string | Path, ignoredPath?: string | Path): boolean;
+    isTouched(path?: string | Path): boolean;
+    touch(path?: string | Path): void;
+    untouch(path?: string | Path): void;
+    getTouchedValue<T = any>(path: string | Path): T;
+    setTouchedValue(path: string | Path, value: any): void;
+    get statuses(): Map<string, ValidationStatus>;
+    get errors(): ValidationStatus[];
+    validate(touchedOnly?: boolean, ignore?: (path: Path, form: FormManager<T>) => boolean): Map<string, ValidationStatus>;
+    validateAt(path: string | Path, touchedOnly?: boolean, skipAsync?: boolean): {
+        changed: boolean;
+        statuses: Map<string, ValidationStatus>;
+    };
+    constraintsAt<MinMax = unknown>(path: string | Path, unsafeMetadata?: boolean): ResolvedConstraints<MinMax> | undefined;
+    updateAsyncStatus(path: string | Path): void;
+    submit(e: FormEvent<HTMLFormElement>): void;
+    scrollToFirstError(errors?: ValidationStatus[]): void;
+    array<T = any>(path: string): ArrayHelper<T> | undefined;
+}
+
+/**
+ * Internal implementation of the ValidationContext interface, used for managing validation state and providing utility methods
+ * for creating child contexts and statuses.
+ * @ignore
+ */
+export declare class InternalValidationContext<Value, Parent = unknown> implements ValidationContext<Value, Parent> {
+    readonly yop: Yop;
+    readonly kind: string;
+    readonly value: Value;
+    readonly path: Path;
+    readonly parentContext: InternalValidationContext<Parent> | undefined;
+    readonly rootContext: InternalValidationContext<unknown> | undefined;
+    readonly settings: ValidationSettings | undefined;
+    readonly store: Map<string, any>;
+    readonly statuses: Map<string, ValidationStatus>;
+    constructor(props: {
+        yop: Yop;
+        kind: string;
+        value: Value;
+        key?: string | number | undefined;
+        parentContext?: InternalValidationContext<Parent> | undefined;
+        rootContext?: InternalValidationContext<unknown> | undefined;
+        userContext?: unknown | undefined;
+        statuses?: Map<string, ValidationStatus>;
+        settings?: ValidationSettings;
+    });
+    ignored(): boolean;
+    get parent(): Parent;
+    get groups(): Group | undefined;
+    get form(): ValidationForm | undefined;
+    getRoot<T>(): T | undefined;
+    createChildContext(props: {
+        kind: string;
+        value: Value;
+        key: string | number;
+    }): InternalValidationContext<Value, Value>;
+    createStatus(code: string, constraint: any, message?: ConstraintMessage, level?: Level): ValidationStatus;
+    setStatus(code: string, constraint: any, message?: ConstraintMessage, level?: Level): ValidationStatus;
+}
+
+/**
+ * Checks if a value is a boolean.
+ * @template T - The boolean type.
+ * @param value - The value to check.
+ * @returns True if value is boolean.
+ * @ignore
+ */
+export declare const isBoolean: <T extends boolean>(value: any) => value is T;
+
+/**
+ * Checks if a value is an array of booleans.
+ * @template T - The boolean type.
+ * @param value - The value to check.
+ * @returns True if value is an array of booleans.
+ * @ignore
+ */
+export declare const isBooleanArray: <T extends boolean>(value: any) => value is Array<T>;
+
+/**
+ * Checks if a value is a valid Date object.
+ * @template T - The Date type.
+ * @param value - The value to check.
+ * @returns True if value is a valid Date.
+ * @ignore
+ */
+export declare const isDate: <T extends Date>(value: any) => value is T;
+
+/**
+ * Checks if a value is an array of Date objects.
+ * @template T - The Date type.
+ * @param value - The value to check.
+ * @returns True if value is an array of Dates.
+ * @ignore
+ */
+export declare const isDateArray: <T extends Date>(value: any) => value is Array<T>;
+
+/**
+ * Checks if a value is a File object.
+ * @template T - The File type.
+ * @param value - The value to check.
+ * @returns True if value is a File.
+ * @ignore
+ */
+export declare const isFile: <T extends File>(value: any) => value is T;
+
+/**
+ * Checks if a value is a function.
+ * @template T - The function type.
+ * @param value - The value to check.
+ * @returns True if value is a function.
+ * @ignore
+ */
+export declare const isFunction: <T extends Function>(value: any) => value is T;
+
+/**
+ * Checks if a value is a valid number (not NaN).
+ * @template T - The number type.
+ * @param value - The value to check.
+ * @returns True if value is a valid number.
+ * @ignore
+ */
+export declare const isNumber: <T extends number>(value: any) => value is T;
+
+/**
+ * Checks if a value is an array of numbers.
+ * @template T - The number type.
+ * @param value - The value to check.
+ * @returns True if value is an array of numbers.
+ * @ignore
+ */
+export declare const isNumberArray: <T extends number>(value: any) => value is Array<T>;
+
+/**
+ * Checks if a value is a non-null object (not an array).
+ * @template T - The object type.
+ * @param value - The value to check.
+ * @returns True if value is an object.
+ * @ignore
+ */
+export declare const isObject: <T extends object>(value: any) => value is T;
+
+/**
+ * Checks if a value is a Promise.
+ * @template T - The Promise type.
+ * @param value - The value to check.
+ * @returns True if value is a Promise.
+ * @ignore
+ */
+export declare const isPromise: <T>(value: any) => value is Promise<T>;
+
+/**
+ * Checks if a value is a RegExp object.
+ * @param value - The value to check.
+ * @returns True if value is a RegExp.
+ * @ignore
+ */
+export declare const isRegExp: (value: any) => value is RegExp;
+
+/**
+ * Checks if a value is a string.
+ * @template T - The string type.
+ * @param value - The value to check.
+ * @returns True if value is a string.
+ * @ignore
+ */
+export declare const isString: <T extends string>(value: any) => value is T;
+
+/**
+ * Checks if a value is an array of strings.
+ * @template T - The string type.
+ * @param value - The value to check.
+ * @returns True if value is an array of strings.
+ * @ignore
+ */
+export declare const isStringArray: <T extends string>(value: any) => value is Array<T>;
+
+/**
+ * Checks if a class constructor is a subclass of another.
+ * @template T - The parent class type.
+ * @param value - The class constructor to check.
+ * @param parent - The parent class constructor.
+ * @returns True if value is a subclass of parent.
+ * @ignore
+ */
+export declare const isSubclassOf: <T>(value: ClassConstructor<any>, parent: ClassConstructor<T>) => value is ClassConstructor<T>;
+
+/**
+ * Joins path segments into a string, using dot/bracket notation as needed.
+ * @param segments - The path segments to join.
+ * @returns The joined path string.
+ * @category Utilities
+ */
+export declare function joinPath(segments: Path): string;
+
+/**
+ * The types of validation status levels. "pending" and "unavailable" are only used for asynchronous validations.
+ * "pending" indicates that the asynchronous validation is in progress, while "unavailable" indicates that the validation
+ * couldn't be performed (e.g., due to an unreachable server).
+ * @see {@link ValidationStatus}
+ * @category Validation Management
+ */
+export declare type Level = "info" | "warning" | "error" | "pending" | "unavailable";
+
+/**
+ * @ignore
+ */
+export declare const localDateToString: (date: Date | null | undefined) => string | null;
+
+/**
+ * Merges default constraint properties into field metadata, applying to all groups if not already set.
+ * @template Constraints - The type of the constraints.
+ * @template Parent - The type of the parent object.
+ * @template Value - The type of the field value.
+ * @param decorator - The field decorator function.
+ * @param defaultProps - The default constraint properties to merge.
+ * @returns A new field decorator function with merged defaults.
+ * @ignore
+ */
+export declare function mergeDefaultMetadata<Constraints extends {}, Parent, Value>(decorator: (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void, defaultProps: Constraints): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Merges constraints from props and groups using a merger function.
+ * @template Constraints - The type of the constraints.
+ * @param props - The main constraints object.
+ * @param groups - Optional groups of constraints.
+ * @param merger - Function to merge each constraints object.
+ * @ignore
+ */
+export declare function mergeMetadata<Constraints>(props?: Constraints, groups?: Groups<Constraints>, merger?: (params: Constraints) => void): void;
+
+/**
+ * A validation message can be defined as a direct string/JSX element or a function returning a message.
+ * @category Shared Constraints
+ */
+export declare type Message<Value, Parent> = ConstraintMessage | ((context: ValidationContext<Value, Parent>) => ConstraintMessage);
+
+/**
+ * Function type for generating a message from message properties.
+ * @see {@link MessageProps}
+ * @category Localization
+ */
+export declare type MessageFunction = (props: MessageProps) => string;
+
+/**
+ * Properties passed to a message function for formatting.
+ * @category Localization
+ */
+export declare type MessageProps = {
+    context: ValidationContext<unknown>;
+    code: string;
+    constraint: {
+        raw: any;
+        formatted: string;
+        plural?: Intl.LDMLPluralRule;
+    };
+    level: Level;
+};
+
+/**
+ * Interface for providing localized validation messages.
+ * @category Localization
+ */
+export declare interface MessageProvider {
+    /**
+     * The locale identifier (e.g., 'en-US', 'fr-FR').
+     */
+    readonly locale: string;
+    /**
+     * Returns a localized message for a given validation context and code.
+     * @param context - The validation context.
+     * @param code - The message code.
+     * @param constraint - The constraint value.
+     * @param message - An optional custom message.
+     * @param level - The validation level (e.g., 'error', 'pending').
+     * @returns The resolved message.
+     */
+    getMessage(context: InternalValidationContext<unknown>, code: string, constraint: any, message: ConstraintMessage | undefined, level: Level): ConstraintMessage;
+}
+
+/**
+ * English (US) message provider for validation messages.
+ * @category Localization
+ */
+export declare const messageProvider_en_US: BasicMessageProvider;
+
+/**
+ * French (FR) message provider for validation messages.
+ * @category Localization
+ */
+export declare const messageProvider_fr_FR: BasicMessageProvider;
+
+/**
+ * Interface for min and max constraints on a value.
+ * @template Value - The type of the value being validated.
+ * @template MinMax - The type for min/max values.
+ * @template Parent - The type of the parent object.
+ * @property min - Minimum constraint for the value, if any.
+ * @property max - Maximum constraint for the value, if any.
+ * @property isMinMaxType - Type guard for min/max values.
+ * @category Shared Constraints
+ */
+export declare interface MinMaxConstraints<Value, MinMax, Parent = unknown> {
+    /**
+     * Minimum constraint for the value. The value must be greater than or equal to this constraint.
+     */
+    min?: Constraint<NonNullable<Value>, MinMax | null | undefined, Parent>;
+    /**
+     * Maximum constraint for the value. The value must be less than or equal to this constraint.
+     */
+    max?: Constraint<NonNullable<Value>, MinMax | null | undefined, Parent>;
+    /**
+     * Optional type guard function to determine if a value is a valid min/max constraint. This can be used to ensure
+     * that the constraint values are of the expected type.
+     */
+    isMinMaxType?: (value: any) => value is MinMax;
+}
+
+/**
+ * Type for a class constructor of a model.
+ * @category Form Management
+ */
+export declare type Model<T> = new (...args: any) => NonNullable<T>;
+
+/**
+ * Decorator for applying validation rules to a number field.
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠number({ required: true, min: 0 })
+ *     age: number | null = null
+ * }
+ * const form = useForm(Person, ...)
+ *
+ * // the number decorator can also be used as a function to allow standalone validation:
+ * Yop.validate(-1, number({ required: true, min: 0 })) // error: "Must be greater or equal to 0"
+ * ```
+ * @template Value - The type of the number value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The number constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export declare function number<Value extends NumberValue, Parent>(constraints?: NumberConstraints<Value, Parent>, groups?: Groups<NumberConstraints<Value, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Interface for number field constraints, combining common, min/max, oneOf, and test constraints.
+ * @template Value - The type of the number value.
+ * @template Parent - The type of the parent object.
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link OneOfConstraint}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export declare interface NumberConstraints<Value extends NumberValue, Parent> extends CommonConstraints<Value, Parent>, MinMaxConstraints<Value, number, Parent>, OneOfConstraint<Value, Parent>, TestConstraint<Value, Parent> {
+}
+
+/**
+ * Type for a number value, which can be a number, null, or undefined.
+ * @ignore
+ */
+export declare type NumberValue = number | null | undefined;
+
+/**
+ * Decorator to register or remove an observer callback for a field. Observer paths use a syntax similar to Unix file paths,
+ * supporting wildcards and array indices, and are relative to the parent object of the field where the observer is attached.
+ * Paths can also be absolute (starting with a slash `/`) to observe fields from the root, or use `..` to observe fields from
+ * higher up in the object tree.
+ *
+ * Observers are only triggered if {@link FormConfig.dispatchEvent} isn't set to `false` and if the class holding `observers`
+ * decorators is bound to the current form using {@link useObservers}.
+ *
+ * Examples:
+ * - `name` observes the `name` field of the parent object.
+ * - `user/name` observes the `name` field of the sibling `user` object.
+ * - `items[*]/price` observes the `price` field of all items in the sibling `items` array.
+ * - `orders[0]/status` observes the `status` field of the first order in the sibling `orders` array.
+ * - `/name` observes the `name` field at the root level.
+ * - `../name` observes the `name` field in the parent of the parent object.
+ *
+ * Example usage:
+ * ```tsx
+ * class MyFormModel {
+ *
+ *    age: number | null = null
+ *
+ *    ＠observer("age", (context) => context.setValue(
+ *          context.observedValue != null ? (context.observedValue as number) >= 18 : null,
+ *          { untouch: true }
+ *    ))
+ *    adult: boolean | null = null
+ * }
+ *
+ * const form = useForm(MyFormModel, ...)
+ *
+ * ```
+ *
+ * @template Value - The type of the field value where the observer is attached.
+ * @template Parent - The parent type containing the field.
+ * @param path - The path to observe.
+ * @param callback - The observer callback function, or undefined to remove it.
+ * @returns A field decorator function.
+ * @category Observers
+ */
+export declare function observer<Value, Parent>(path: string, callback: ObserverCallback<Value> | undefined): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Observer callback function type.
+ *
+ * @template T - The type of the field value where the observer is attached.
+ * @param context - The context for the observer callback. See {@link ObserverCallbackContext}.
+ * @category Observers
+ */
+export declare type ObserverCallback<T> = (context: ObserverCallbackContext<T>) => void;
+
+/**
+ * Context object passed to observer callbacks.
+ *
+ * @template T - The type of the field value where the observer is attached.
+ * @category Observers
+ */
+export declare type ObserverCallbackContext<T> = {
+    /** The absolute path of the field value where the observer is attached */
+    path: Path;
+    /** The value being observed. */
+    observedValue: unknown;
+    /** The current value of the field where the observer is attached. */
+    currentValue: T;
+    /** Sets the value of the field where the observer is attached. */
+    setValue: (value: T, options?: ObserverCallbackOptions) => void;
+    /** The event object providing context. See {@link ReformSetValueEvent}. */
+    event: ReformSetValueEvent<unknown>;
+};
+
+/**
+ * Options for observer callback behavior.
+ * @category Observers
+ */
+export declare type ObserverCallbackOptions = {
+    /** If `true`, marks the field as untouched. */
+    untouch?: boolean;
+    /** If `true`, propagates the value change to other observers. Defaults to `false` to prevent potential infinite loops*/
+    propagate?: boolean;
+};
+
+/**
+ * Metadata for an observer, including its path and callback.
+ *
+ * @template T - The type of the field value where the observer is attached.
+ * @ignore
+ */
+export declare type ObserverMetadata<T> = {
+    /** The path of the field being observed. */
+    path: string;
+    /** The observer callback function. */
+    callback: ObserverCallback<T>;
+};
+
+/**
+ * Map of observer metadata, keyed by observed path.
+ * @ignore
+ */
+export declare type Observers = Map<string, ObserverMetadata<any>>;
+
+/**
+ * Field metadata type that can hold observers in addition to common constraints.
+ * @ignore
+ */
+export declare type ObserversField = InternalCommonConstraints & {
+    observers?: Observers;
+};
+
+/**
+ * Interface for a constraint that checks if a value is one of a set of allowed values.
+ * @template Value - The type of the value being validated.
+ * @template Parent - The type of the parent object.
+ * @property oneOf - Constraint for allowed values, if any.
+ * @category Shared Constraints
+ */
+export declare interface OneOfConstraint<Value, Parent = unknown> {
+    oneOf?: Constraint<NonNullable<Value>, NoInfer<NonNullable<Value>>[], Parent>;
+}
+
+/**
+ * Type for a parsed path, as an array of string or number segments. Numbers represent array indices, while strings represent object keys. This type
+ * is used for efficient access to nested properties in objects or arrays.
+ * @see {@link splitPath}
+ * @category Utilities
+ */
+export declare type Path = (string | number)[];
+
+/**
+ * Static configuration for form error display and logging.
+ * @category Form Management
+ */
+export declare class Reform {
+    /**
+     * Whether to display form errors in the UI (debug only).
+     */
+    static displayFormErrors: boolean;
+    /**
+     * Whether to log form errors to the console (debug only).
+     */
+    static logFormErrors: boolean;
+}
+
+/**
+ * Settings for constraintsAt validation, combining reform and Yop constraint settings.
+ * @ignore
+ */
+export declare interface ReformConstraintsAtSettings extends ReformValidationSettings, ConstraintsAtSettings {
+}
+
+/**
+ * The ReformEvents type is a generic type that takes two parameters: Value, which represents the type of the value being handled, and Root,
+ * which extends object and represents the type of the form's root state. It defines two optional event handler properties: onChange and onBlur.
+ * Both handlers receive the current value (which can be of type Value or null) and an instance of FormManager that manages the form's state.
+ * This allows for handling changes and blur events in a way that is integrated with the form management system.
+ * @category Base Inputs Components
+ */
+export declare type ReformEvents<Value, Root extends object = any> = {
+    onChange?: (value: Value | null, form: FormManager<Root>) => void;
+    onBlur?: (value: Value | null, form: FormManager<Root>) => void;
+};
+
+/**
+ * Event fired when a value is set in the form, used for observer propagation.
+ * @template T - The type of the value being set.
+ * @category Form Management
+ */
+export declare interface ReformSetValueEvent<T = any> extends CustomEvent<{
+    readonly form: FormManager<unknown>;
+    readonly path: string;
+    readonly previousValue: T;
+    readonly value: T;
+    readonly options: SetValueOptionsObject;
+}> {
+}
+
+/**
+ * Validation settings for reform forms, extending base validation settings.
+ * @property method - The validation method to use.
+ * @ignore
+ */
+export declare interface ReformValidationSettings extends ValidationSettings {
+    method: "validate" | "validateAt" | "constraintsAt";
+}
+
+/**
+ * Type for resolved constraints, including required, min, and max.
+ * @template MinMax - The type for min/max values.
+ * @category Validation Management
+ */
+export declare type ResolvedConstraints<MinMax = unknown> = {
+    /**
+     * Whether the field is required.
+     */
+    required: boolean;
+    /**
+     * The minimum value or length for the field, if applicable.
+     */
+    min?: MinMax;
+    /**
+     * The maximum value or length for the field, if applicable.
+     */
+    max?: MinMax;
+};
+
+/**
+ * Sets a value in an object or array at a given path, optionally cloning and using a condition.
+ * @param value - The root object or array.
+ * @param path - The path string or array.
+ * @param newValue - The value to set.
+ * @param cache - Optional cache for parsed paths.
+ * @param options - Optional settings for cloning and condition.
+ * @returns The set result, including root and previous value.
+ * @category Utilities
+ */
+export declare function set(value: unknown, path: string | Path, newValue: unknown, cache?: Map<string, Path>, options?: {
+    clone?: boolean;
+    condition?: (currentValue: unknown) => boolean;
+}): SetResult;
+
+/**
+ * Result type for set operation, including root and previous value.
+ * @category Utilities
+ */
+export declare type SetResult = undefined | {
+    root: unknown;
+    previousValue?: unknown;
+};
+
+/**
+ * Options for setValue: either a boolean (validate) or an options object.
+ * @category Form Management
+ */
+export declare type SetValueOptions = boolean | SetValueOptionsObject;
+
+/**
+ * Options object for setValue operations.
+ * @property touch - Whether to mark the field as touched.
+ * @property validate - Whether to validate after setting the value.
+ * @property propagate - Whether to propagate the change to observers.
+ * @category Form Management
+ */
+export declare type SetValueOptionsObject = {
+    /** Whether to mark the field as touched. */
+    touch?: boolean;
+    /** Whether to validate after setting the value. */
+    validate?: boolean;
+    /** Whether to propagate the change to observers. */
+    propagate?: boolean;
+};
+
+/**
+ * Splits a string path into segments, handling dot/bracket/quote notation.
+ * @param path - The path string to split.
+ * @param cache - Optional cache for parsed paths.
+ * @returns The parsed path as an array, or undefined if invalid.
+ * @category Utilities
+ */
+export declare function splitPath(path: string, cache?: Map<string, Path>): Path | undefined;
+
+/**
+ * Decorator for applying validation rules to a string field. A required string field can be an empty string, but neither `null` nor `undefined`.
+ * To enforce non-empty strings, use the `min` constraint with a value of 1.
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠string({ required: true, min: 1 })
+ *     name: string | null = null
+ * }
+ * const form = useForm(Person, ...)
+ *
+ * // the string decorator can also be used as a function to allow standalone validation:
+ * Yop.validate("", string({ required: true, min: 1 })) // error: "Minimum 1 character"
+ * ```
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The string constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @category Property Decorators
+ */
+export declare function string<Value extends StringValue, Parent>(constraints?: StringConstraints<Value, Parent>, groups?: Groups<StringConstraints<Value, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Interface for string field constraints, combining common, min/max, oneOf, test, and match constraints.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @property match - Constraint for matching a regular expression.
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link OneOfConstraint}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export declare interface StringConstraints<Value extends StringValue, Parent> extends CommonConstraints<Value, Parent>, MinMaxConstraints<Value, number, Parent>, OneOfConstraint<Value, Parent>, TestConstraint<Value, Parent> {
+    /**
+     * Constraint for matching a regular expression. The constraint value can be a RegExp, a function that returns a RegExp.
+     */
+    match?: Constraint<NonNullable<Value>, RegExp, Parent>;
+}
+
+/**
+ * @ignore
+ */
+export declare const stringToLocalDate: (value: unknown) => Date | null;
+
+/**
+ * Type for a string value, which can be a string, null, or undefined.
+ * @ignore
+ */
+export declare type StringValue = string | null | undefined;
+
+/**
+ * Class decorator to add a test constraint function to a class for validation. The test function will be called with the
+ * class instance after all field validations have passed, allowing for complex custom validation logic that depends on
+ * the entire object state.
+ *
+ * Example usage:
+ * ```tsx
+ * ＠test(credentials => credentials.password === credentials.confirmPassword ? true : "Passwords do not match")
+ * class Credentials {
+ *     ＠string({ required: true, min: 8 })
+ *     username: string | null = null
+ *     ＠string({ required: true, min: 8, test: checkPasswordStrength })
+ *     password: string | null = null
+ *     ＠string({ required: true, min: 8 })
+ *     confirmPassword: string | null = null
+ * }
+ * const form = useForm(Credentials, ...)
+ * ```
+ * @template Class - The constructor type of the class.
+ * @param test - The test constraint function to apply to the class instance.
+ * @returns A class decorator function that sets the test constraint.
+ * @see {@link TestConstraintFunction}
+ * @category Class Decorators
+ */
+export declare function test<Class extends Constructor>(test: TestConstraintFunction<InstanceType_2<Class>>): (_: Class, context: ClassDecoratorContext<Class>) => void;
+
+/**
+ * Interface for a test constraint, which can be sync, async, or both.
+ * @template Value - The type of the value being validated.
+ * @template Parent - The type of the parent object.
+ * @property test - The test constraint function or async constraint.
+ * @category Shared Constraints
+ */
+export declare interface TestConstraint<Value, Parent = unknown> {
+    test?: TestConstraintFunction<Value, Parent> | AsyncTestConstraint<Value, Parent> | readonly [TestConstraintFunction<Value, Parent>, AsyncTestConstraint<Value, Parent>];
+}
+
+/**
+ * Type for a test constraint function, which can return a test constraint message or be undefined.
+ * @template Value - The type of the value being validated.
+ * @template Parent - The type of the parent object.
+ * @category Shared Constraints
+ */
+export declare type TestConstraintFunction<Value, Parent = unknown> = ConstraintFunction<NonNullable<Value>, TestConstraintMessage, Parent>;
+
+/**
+ * Type for test constraint messages, which can be a simple message, a tuple of message and level, a boolean, or undefined.
+ * @category Shared Constraints
+ */
+export declare type TestConstraintMessage = ConstraintMessage | readonly [ConstraintMessage, Level] | boolean | undefined;
+
+/**
+ * Decorator for applying validation rules to a time field. A valid time value must be a string in the format HH:mm[:ss[.sss]] (24-hour clock).
+ *
+ * Example usage:
+ * ```tsx
+ * class Person {
+ *     ＠time({ required: true, formatError: "Invalid wake up time format", max: "18:00" })
+ *     wakeUpTime: string | null = null
+ * }
+ * const form = useForm(Person, ...)
+ *
+ * // the time decorator can also be used as a function to allow standalone validation:
+ * Yop.validate("00:00", time({ min: "01:00" })) // error: "Must be after or equal to 01:00"
+ * ```
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param constraints - The time constraints to apply.
+ * @param groups - Optional validation groups.
+ * @returns A field decorator function with validation.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Date_and_time_formats#time_strings
+ * @category Property Decorators
+ */
+export declare function time<Value extends StringValue, Parent>(constraints?: TimeConstraints<Value, Parent>, groups?: Groups<TimeConstraints<Value, Parent>>): (_: unknown, context: ClassFieldDecoratorContext<Parent, Value>) => void;
+
+/**
+ * Interface for time field constraints, combining common, min/max, oneOf, and test constraints.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @property formatError - Optional custom error message for invalid time format.
+ * @see {@link CommonConstraints}
+ * @see {@link MinMaxConstraints}
+ * @see {@link OneOfConstraint}
+ * @see {@link TestConstraint}
+ * @category Property Decorators
+ */
+export declare interface TimeConstraints<Value extends StringValue, Parent> extends CommonConstraints<Value, Parent>, MinMaxConstraints<Value, string, Parent>, OneOfConstraint<Value, Parent>, TestConstraint<Value, Parent> {
+    /**
+     * Optional custom error message for invalid time format. `formatError` can be a {@link Message} or a function that returns a {@link Message}.
+     * @see {@link timeRegex}
+     */
+    formatError?: Message<Value, Parent>;
+}
+
+/**
+ * Regular expression for validating time strings in the format HH:mm[:ss[.sss]].
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Date_and_time_formats#time_strings
+ * @ignore
+ */
+export declare const timeRegex: RegExp;
+
+/**
+ * Converts a time string (HH:mm[:ss[.sss]]) to milliseconds since midnight.
+ * @param time - The time string to convert.
+ * @returns The number of milliseconds since midnight, or undefined if invalid.
+ * @ignore
+ */
+export declare function timeToMillis(time: string): number | undefined;
+
+/**
+ * Traverses a class field to retrieve its constraints and value.
+ * @param context - The validation context for the class.
+ * @param constraints - The class constraints.
+ * @param key - The field name or index to traverse.
+ * @param traverseNullish - If true, traverses only if value is not nullish; otherwise, returns undefined for nullish values.
+ * @returns A tuple of the field constraints (if any) and the value at the given key.
+ * @ignore
+ */
+export declare function traverseClass(context: InternalValidationContext<unknown>, constraints: InternalClassConstraints, key: string | number, traverseNullish?: boolean): readonly [InternalCommonConstraints | undefined, any];
+
+/**
+ * Type for a function that traverses nested constraints and values.
+ * @ignore
+ */
+export declare type Traverser<Constraints, Value = ContraintsValue<Constraints>, Parent = ContraintsParent<Constraints>> = ((context: InternalValidationContext<Value, Parent>, constraints: Constraints, propertyOrIndex: string | number, traverseNullish?: boolean) => readonly [InternalCommonConstraints | undefined, InternalValidationContext<unknown>]);
+
+/**
+ * @ignore
+ */
+export declare const UndefinedParent: any;
+
+/**
+ * Type for resolved constraints with an editable field metadata. *Warning*: the `fieldMetadata` property is mutable and should be used with
+ * caution, as modifying it can lead to unexpected behavior in validation logic. It is intended for advanced use cases where access to the
+ * original constraints is necessary, but it should not be modified during normal validation operations.
+ * @template MinMax - The type for min/max values.
+ * @category Validation Management
+ */
+export declare type UnsafeResolvedConstraints<MinMax = unknown> = ResolvedConstraints<MinMax> & {
+    fieldMetadata?: CommonConstraints<any, any> | undefined;
+};
+
+/**
+ * Removes a value from an object or array at a given path.
+ * @param value - The root object or array.
+ * @param path - The path string or array.
+ * @param cache - Optional cache for parsed paths.
+ * @returns True if unset, false otherwise.
+ * @category Utilities
+ */
+export declare function unset(value: unknown, path: string | Path, cache?: Map<string, Path>): boolean | undefined;
+
+/**
+ * ## First overload signature
+ *
+ * React hook to create and manage a form with all configuration options available in {@link FormConfig}. This overload allows for the most flexible
+ * usage of the `useForm` hook, with full control over initial values, validation schema, submission logic, and more.
+ *
+ * However, it doesn't register automatically observers listeners, and you need to use the {@link useObservers} hook manually to register observers on
+ * the form manager instance, as shown in the example below.
+ *
+ * Example usage:
+ * ```tsx
+ * const form = useForm({
+ *     initialValues: new Person(),
+ *     validationSchema: instance({ of: Person, required: true }),
+ *     onSubmit: (form) => {
+ *         console.log("Form submitted with values:", form.values)
+ *         form.setSubmitting(false)
+ *     }
+ * })
+ * // Optional, if observers are used in the form:
+ * useObservers(Person, form)
+ * ```
+ * @overload@overload
+ * @template T - The type of the form values.
+ * @param config - The form configuration object.
+ * @param deps - Optional dependency list for memoization of the form manager.
+ * @returns The form manager instance.
+ * @category Form Management
+ */
+export declare function useForm<T extends object | null | undefined>(config: FormConfig<T>, deps?: React.DependencyList): FormManager<T>;
+
+/**
+ * ## Second overload signature
+ *
+ * React hook to create and manage a form with validation, and automatic observer support. This overload allows for a simpler syntax. The initial values
+ * will be created by instantiating the provided model class, and the validation schema will be automatically generated using the `instance` decorator with
+ * the provided model class and `required: true`.
+ *
+ * There is no need to use {@link useObservers} here, observers will be automatically registered on the form manager instance
+ * for the provided model class. The code example below is strictly equivalent to the one in the other overload signature,
+ * but with a simpler syntax.
+ *
+ * Example usage:
+ * ```tsx
+ * const form = useForm(Person, (form) => {
+ *     console.log("Form submitted with values:", form.values)
+ *     form.setSubmitting(false)
+ * })
+ * ```
+ *
+ * @overload@overload
+ * @template T - The type of the form values.
+ * @param model - The model class constructor.
+ * @param onSubmit - Callback for form submission.
+ * @param deps - Optional dependency list for memoization of the form manager.
+ * @returns The form manager instance.
+ * @category Form Management
+ */
+export declare function useForm<T extends object | null | undefined>(model: Model<T>, onSubmit: (form: FormManager<T>) => void, deps?: React.DependencyList): FormManager<T>;
+
+/**
+ * React hook to access the current {@link FormManager} from context. This hook should be used within a component that is a descendant of a {@link Form} component,
+ * which provides the FormManager via context. The generic type parameter `T` can be used to specify the type of the form values managed by the FormManager,
+ * allowing for type-safe access to form values.
+ *
+ * Example usage:
+ * ```tsx
+ * function MyFormComponent() {
+ *     const form = useFormContext<MyFormValues>()
+ *     // use form to access values, statuses, etc.
+ * }
+ *
+ * const form = useForm(MyFormModel, onSubmit)
+ * return (
+ *     <Form form={form} autoComplete="off" noValidate disabled={form.submitting}>
+ *        <MyFormComponent />
+ *     </Form>
+ * )
+ * ```
+ *
+ * @template T - The type of the form values managed by the FormManager.
+ * @returns The {@link FormManager} instance from context.
+ * @category Form Management
+ */
+export declare function useFormContext<T = unknown>(): FormManager<T>;
+
+/**
+ * React hook to access and manage the state of a form field, including value, validation status, and constraints.
+ * Handles async validation and triggers re-renders as needed.
+ *
+ * Example usage:
+ * ```tsx
+ * function MyTextField(props: { path: string }) {
+ *     const { constraints, status, value, form } = useFormField<string, number>(props.path)
+ *     // render input with value, display validation status, etc.
+ * }
+ * ```
+ *
+ * @template Value - The type of the field value.
+ * @template MinMax - The type for min/max constraints.
+ * @template Root - The type of the root form values.
+ * @param name - The field name or path.
+ * @param unsafeMetadata - Whether to use unsafe metadata for constraints.
+ * @returns The current state of the field. See {@link FieldState} for details.
+ * @category Form Management
+ */
+export declare function useFormField<Value, MinMax, Root = any>(name: string, unsafeMetadata?: boolean): FieldState<Value, MinMax, Root>;
+
+/**
+ * React hook to register reform event listeners for {@link observer}s on a model. This hook scans the provided model class for any observer metadata
+ * and registers a single event listener on the form manager instance that will trigger the appropriate observer callbacks when relevant fields
+ * are updated.
+ *
+ * There is no need to use this hook if you are using the {@link useForm} hook with a model class, as observers will be automatically registered on
+ * the form manager instance.
+ *
+ * Example usage:
+ * ```tsx
+ * const form = useForm({
+ *     initialValues: new MyFormModel(),
+ *     validationSchema: instance({ of: MyFormModel }),
+ *     onSubmit: (form) => { ... }
+ * })
+ * useObservers(MyFormModel, form)
+ * ```
+ *
+ * @template T
+ * @param model - The class constructor to scan for observers.
+ * @param form - The form manager instance holding the values to observe.
+ * @category Observers
+ */
+export declare function useObservers<T extends object>(model: ClassConstructor<T> | null | undefined, form: FormManager<unknown>): void;
+
+/**
+ * React hook that returns a function to force a component re-render.
+ * Useful for triggering updates in custom hooks or non-stateful logic.
+ *
+ * @returns A function that, when called, forces the component to re-render.
+ * @category Form Management
+ */
+export declare function useRender(): () => void;
+
+/**
+ * Validates a class object against its constraints, including all fields and test constraints.
+ * @param context - The validation context for the class object.
+ * @param constraints - The class constraints to validate.
+ * @returns True if all constraints pass, false otherwise.
+ * @ignore
+ */
+export declare function validateClass(context: InternalValidationContext<{
+    [x: string]: any;
+}>, constraints: InternalClassConstraints): boolean;
+
+/**
+ * Validates the common constraints (defined, notnull, required) for a value.
+ * @template Value - The type of the value being validated.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The constraints to validate.
+ * @returns True if all constraints pass, false otherwise.
+ * @ignore
+ */
+export declare function validateCommonConstraints<Value, Parent>(context: InternalValidationContext<Value, Parent>, constraints: CommonConstraints<Value, Parent>): boolean;
+
+/**
+ * Validates a constraint for a given context and constraint definition.
+ * Handles group-based constraints and default values/messages.
+ *
+ * @template Value - The type of the value being validated.
+ * @template ConstraintType - The type of the constraint value.
+ * @template Parent - The type of the parent object.
+ * @template Constraints - The type of the constraints object.
+ * @param context - The validation context.
+ * @param constraints - The constraints object.
+ * @param name - The name of the constraint to validate.
+ * @param isConstraintType - Type guard for the constraint value.
+ * @param validate - Function to validate the value against the constraint.
+ * @param defaultConstraint - Optional default constraint value.
+ * @param defaultMessage - Optional default error message.
+ * @param setStatus - Whether to set the status on failure (default: true).
+ * @returns True if the constraint passes, false otherwise.
+ * @ignore
+ */
+export declare function validateConstraint<Value, ConstraintType, Parent, Constraints = {
+    [name: string]: Constraint<Value, ConstraintType, Parent>;
+}>(context: InternalValidationContext<Value, Parent>, constraints: Constraints, name: keyof Constraints, isConstraintType: (value: any) => value is ConstraintType, validate: (value: Value, constraintValue: NonNullable<ConstraintType>) => boolean, defaultConstraint?: ConstraintType, defaultMessage?: Message<Value, Parent>, setStatus?: boolean): boolean;
+
+/**
+ * Validates an email field against its constraints and the email regex.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The email constraints to validate.
+ * @returns True if the value is a valid email, false otherwise.
+ * @ignore
+ */
+export declare function validateEmail<Value extends StringValue, Parent>(context: InternalValidationContext<Value, Parent>, constraints: EmailConstraints<Value, Parent>): boolean;
+
+/**
+ * Validates min and max constraints for a value.
+ * @template Value - The type of the value being validated.
+ * @template MinMax - The type for min/max values.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The min/max constraints to validate.
+ * @param isConstraintValue - Type guard for min/max values.
+ * @param validateMin - Function to validate the min constraint.
+ * @param validateMax - Function to validate the max constraint.
+ * @returns True if both min and max constraints pass, false otherwise.
+ * @ignore
+ */
+export declare function validateMinMaxConstraints<Value, MinMax, Parent>(context: InternalValidationContext<Value, Parent>, constraints: MinMaxConstraints<Value, MinMax, Parent>, isConstraintValue: (value: any) => value is MinMax, validateMin: (value: NonNullable<Value>, min: NonNullable<MinMax>) => boolean, validateMax: (value: NonNullable<Value>, max: NonNullable<MinMax>) => boolean): boolean;
+
+/**
+ * Validates the oneOf constraint for a value.
+ * @template Value - The type of the value being validated.
+ * @template OneOfType - The type for the allowed values array.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The oneOf constraint to validate.
+ * @param isConstraintValue - Type guard for the allowed values array.
+ * @param equals - Optional equality function for comparing values.
+ * @returns True if the value is one of the allowed values, false otherwise.
+ * @ignore
+ */
+export declare function validateOneOfConstraint<Value, OneOfType extends NoInfer<NonNullable<Value>>[], Parent>(context: InternalValidationContext<Value, Parent>, constraints: OneOfConstraint<Value, Parent>, isConstraintValue: (value: any) => value is OneOfType, equals?: (value1: NonNullable<Value>, value2: NonNullable<Value>) => boolean): boolean;
+
+/**
+ * Validates a string field against its constraints.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The string constraints to validate.
+ * @param defaultRegexp - Optional default regular expression for matching.
+ * @param defaultMatchMessage - Optional default error message for match failures.
+ * @param type - Optional type name for error reporting.
+ * @returns True if all constraints pass, false otherwise.
+ * @ignore
+ */
+export declare function validateString<Value extends StringValue, Parent>(context: InternalValidationContext<Value, Parent>, constraints: StringConstraints<Value, Parent>, defaultRegexp?: RegExp, defaultMatchMessage?: Message<Value, Parent>, type?: string): boolean;
+
+/**
+ * Validates a test constraint for a value, handling sync and async cases.
+ * @template Value - The type of the value being validated.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param testConstraint - The test constraint to validate.
+ * @returns True if the constraint passes, false otherwise.
+ * @ignore
+ */
+export declare function validateTestConstraint<Value, Parent>(context: InternalValidationContext<Value, Parent>, testConstraint: TestConstraint<Value, Parent>): boolean;
+
+/**
+ * Validates a time field against its constraints.
+ * @template Value - The type of the string value.
+ * @template Parent - The type of the parent object.
+ * @param context - The validation context.
+ * @param constraints - The time constraints to validate.
+ * @returns True if all constraints pass, false otherwise.
+ * @ignore
+ */
+export declare function validateTime<Value extends StringValue, Parent>(context: InternalValidationContext<Value, Parent>, constraints: TimeConstraints<Value, Parent>): boolean;
+
+/**
+ * Validates the type of a value using a provided type check function.
+ * @param context - The validation context.
+ * @param checkType - Function to check the value's type.
+ * @param expectedType - The expected type as a string.
+ * @returns True if the value matches the expected type, false otherwise.
+ * @ignore
+ */
+export declare function validateTypeConstraint(context: InternalValidationContext<any>, checkType: (value: any) => boolean, expectedType: string): boolean;
+
+/**
+ * Interface representing the context of a validation operation, providing access to the value being validated, its path,
+ * parent context, root context, settings, form, and a store for sharing data across validations.
+ *
+ * @template Value - The type of the value being validated.
+ * @template Parent - The type of the parent object containing the value.
+ * @category Validation Management
+ */
+export declare interface ValidationContext<Value, Parent = unknown> {
+    readonly kind: string;
+    readonly value: Value;
+    readonly path: Path;
+    readonly parent: Parent;
+    readonly parentContext: ValidationContext<Parent> | undefined;
+    getRoot<T>(): T | undefined;
+    readonly rootContext: ValidationContext<unknown> | undefined;
+    readonly settings: ValidationSettings | undefined;
+    readonly form: ValidationForm | undefined;
+    readonly store: Map<string, any>;
+}
+
+/**
+ * Base interface of a form manager, extended by {@link FormManager}, representing form state and operations.
+ * @category Validation Management
+ */
+export declare interface ValidationForm {
+    /**
+     * Whether the form has been submitted at least once, even if the submission was unsuccessful.
+     */
+    readonly submitted: boolean;
+    /**
+     * Whether the form is currently being submitted.
+     */
+    readonly submitting: boolean;
+    /**
+     * Map of validation statuses for each field.
+     */
+    readonly statuses: Map<string, ValidationStatus>;
+    /**
+     * List of all errors in the form: this includes all validation statuses with a severity level of "error".
+     */
+    readonly errors: ValidationStatus[];
+    /**
+     * A map that can be used to store arbitrary data related to the form.
+     */
+    readonly store: Map<string, any>;
+    /**
+     * The HTML form element associated with this validation form.
+     */
+    readonly htmlForm?: HTMLFormElement;
+    /**
+     * Retrieves the value of a field by its path.
+     * @template T - The expected type of the field value.
+     * @param path - The path to the field.
+     * @returns The value of the field, or undefined if not found.
+     */
+    getValue<T = any>(path: string | Path): T | undefined;
+    /**
+     * Checks if a field has been touched.
+     * @param path - The path to the field.
+     * @returns True if the field has been touched, false otherwise.
+     */
+    isTouched(path?: string | Path): boolean;
+    /**
+     * Marks a field as touched.
+     * @param path - The path to the field.
+     */
+    touch(path?: string | Path): void;
+    /**
+     * Marks a field as untouched.
+     * @param path - The path to the field.
+     */
+    untouch(path?: string | Path): void;
+    /**
+     * Checks if a field is dirty (has been modified). If no path is provided, checks if any field in the entire form is dirty.
+     * @param path - The path to the field.
+     * @param ignoredPath - Optional path to ignore during the check.
+     * @returns True if the field is dirty, false otherwise.
+     */
+    isDirty(path?: string | Path, ignoredPath?: string | Path): boolean;
+}
+
+/**
+ * Interface for validation settings, including path, groups, and options.
+ * @category Validation Management
+ */
+export declare interface ValidationSettings {
+    /**
+     * The path to the field or object being validated. This can be a string with dot notation (e.g., "address.street") or
+     * an array of path segments (e.g., ["address", "street"]). If omitted, the validation will be performed on the root value.
+     */
+    path?: string | Path;
+    /**
+     * Validation groups to apply during validation. This can be a single group or an array of groups. If specified, only the
+     * constraints associated with at least one of the active groups will be validated.
+     */
+    groups?: Group;
+    /**
+     * Function to determine if a path should be ignored during validation.
+     */
+    ignore?: (path: Path) => boolean;
+    /**
+     * Whether to skip asynchronous validation.
+     */
+    skipAsync?: boolean;
+    /**
+     * The validation form associated with this validation context. This form is set by the form manager when performing form-level validation
+     * and can be used to access form state and operations during validation.
+     */
+    form?: ValidationForm;
+}
+
+/**
+ * Interface representing the status of a validation, including its level, path, value, kind, code, constraint, and message.
+ * This is used to track the results of validation operations and provide feedback to the user.
+ * @category Validation Management
+ */
+export declare type ValidationStatus = {
+    /**
+     * The severity level of the validation status, or the status of asynchronous validation.
+     * @see {@link Level}
+     */
+    level: Level;
+    /**
+     * The path to the validated value, represented as a string (e.g., "users[0].address.street").
+     */
+    path: string;
+    /**
+     * The value that was validated.
+     */
+    value: any;
+    /**
+     * The kind of validation (e.g., "string", "number", "array"), used for message resolution.
+     */
+    kind: string;
+    /**
+     * A code representing the specific validation type (e.g., "required", "min"), used for message resolution.
+     */
+    code: string;
+    /**
+     * The constraint value that caused the validation error (e.g., `true` for a "required" constraint, `1` for a "min" constraint).
+     */
+    constraint: any;
+    /**
+     * The resolved message for this validation status, which can be displayed to the user.
+     */
+    message: ConstraintMessage;
+};
+
+/**
+ * Symbol used to store validation metadata on class fields. This symbol is used as a key to attach validation constraints and related
+ * information to class properties.
+ * @ignore
+ */
+export declare const validationSymbol: unique symbol;
+
+/**
+ * Type for a validation function for a set of constraints.
+ * @ignore
+ */
+export declare type Validator<Constraints, Value = ContraintsValue<Constraints>, Parent = ContraintsParent<Constraints>> = (context: InternalValidationContext<Value, Parent>, constraints: Constraints) => boolean;
+
+/**
+ * @ignore
+ */
+export declare type ValuedContext<Value, Parent> = InternalValidationContext<NonNullable<Value>, Parent>;
+
+/**
+ * Main class for validation logic, constraint resolution, and message provider management.
+ * @category Validation Management
+ */
+export declare class Yop {
+    private static defaultInstance?;
+    private static classIds;
+    private static messageProviders;
+    private locale;
+    private _store;
+    private _asyncStatuses;
+    /**
+     * Gets the store map, which can be used to store arbitrary data related to validation operations. This allows sharing data across different
+     * validation contexts and operations.
+     */
+    get store(): Map<string, any>;
+    /**
+     * Gets the map of asynchronous validation statuses, where each key is a path and the value is the corresponding asynchronous validation status.
+     */
+    get asyncStatuses(): Map<string, AsyncValidationStatus>;
+    /**
+     * Registers a class constructor with a given ID.
+     * @param id The ID to associate with the class constructor.
+     * @param constructor The class constructor to register.
+     * @ignore
+     */
+    static registerClass(id: string, constructor: Constructor<unknown>): void;
+    /**
+     * Resolves a class constructor by its ID.
+     * @param id The ID of the class or a function reference.
+     * @param silent If true, suppresses error messages for unregistered classes.
+     * @returns The resolved class constructor, or undefined if not found.
+     * @ignore
+     */
+    static resolveClass<T>(id: unknown, silent?: boolean): Constructor<T> | undefined;
+    private contextAt;
+    /**
+     * Retrieves the constraints for a given class field decorator and value, using the provided settings.
+     * @param decorator The class field decorator defining the constraints.
+     * @param value The value to be validated against the constraints.
+     * @param settings Optional settings for constraint resolution, including path and unsafe metadata flag.
+     * @returns The resolved constraints, or undefined if no constraints are found.
+     */
+    constraintsAt<MinMax = unknown>(decorator: ClassFieldDecorator<any>, value: any, settings?: ConstraintsAtSettings): ResolvedConstraints<MinMax> | undefined;
+    /**
+     * Static version of the constraintsAt method, which initializes the Yop instance and retrieves the constraints for a given class field decorator and value.
+     * @param decorator The class field decorator defining the constraints.
+     * @param value The value to be validated against the constraints.
+     * @param settings Optional settings for constraint resolution, including path and unsafe metadata flag.
+     * @returns The resolved constraints, or undefined if no constraints are found.
+     */
+    static constraintsAt<Value>(decorator: ClassFieldDecorator<Value>, value: any, settings?: ConstraintsAtSettings): ResolvedConstraints<unknown> | undefined;
+    /**
+     * Retrieves the asynchronous validation status for a given path. The path can be a string or an array of path segments.
+     * @param path The path for which to retrieve the asynchronous validation status.
+     * @returns The asynchronous validation status, or undefined if not found.
+     */
+    getAsyncStatus(path: string | Path): ValidationStatus | undefined;
+    /**
+     * Validates a value against the constraints defined by a class field decorator, using the provided validation settings. This method performs
+     * the validation logic and returns the validation context, which includes the results of the validation operation. The context contains
+     * information about the value, its path, any validation statuses.
+     * @param value The value to be validated.
+     * @param decorator The decorator defining the validation constraints.
+     * @param settings The validation settings, including the path and other options.
+     * @returns The validation context after performing the validation.
+     * @ignore
+     */
+    rawValidate<Value>(value: any, decorator: ClassFieldDecorator<Value>, settings?: ValidationSettings): InternalValidationContext<any, unknown> | undefined;
+    /**
+     * Validates a value against the constraints defined by a class field decorator, using the provided validation settings. This method performs
+     * the validation logic and returns the validation statuses array.
+     * @param value The value to be validated.
+     * @param decorator The decorator defining the validation constraints.
+     * @param settings The validation settings, including the path and other options.
+     * @returns An array of validation statuses after performing the validation.
+     */
+    validate<Value>(value: any, decorator: ClassFieldDecorator<Value>, settings?: ValidationSettings): ValidationStatus[];
+    /**
+     * Static version of the validate method, which initializes the Yop instance and performs validation on the provided value using the specified
+     * decorator and settings.
+     * @param value The value to be validated.
+     * @param decorator The decorator defining the validation constraints.
+     * @param settings The validation settings, including the path and other options.
+     * @returns An array of validation statuses after performing the validation.
+     * @see {@link Yop#validate}
+     */
+    static validate<Value>(value: any, decorator: ClassFieldDecorator<Value>, settings?: ValidationSettings): ValidationStatus[];
+    /**
+     * Registers a message provider for a specific locale. The message provider is used to retrieve localized validation messages
+     * based on the current locale setting.
+     * @param provider The message provider to register.
+     */
+    static registerMessageProvider(provider: MessageProvider): void;
+    /**
+     * Gets the current locale used for message resolution. This locale determines which message provider is used to retrieve validation messages.
+     * @returns The current locale as a string.
+     */
+    getLocale(): string;
+    /**
+     * Static version of the getLocale method, which initializes the Yop instance and retrieves the current locale.
+     * @returns The current locale as a string.
+     * @see {@link Yop#getLocale}
+     */
+    static getLocale(): string;
+    /**
+     * Sets the current locale used for message resolution. This locale determines which message provider is used to retrieve validation messages.
+     * @param locale The locale to set. This should be a valid BCP 47 language tag (e.g., "en-US", "fr-FR").
+     */
+    setLocale(locale: string): void;
+    /**
+     * Static version of the setLocale method, which initializes the Yop instance and sets the current locale.
+     * @param locale The locale to set. This should be a valid BCP 47 language tag (e.g., "en-US", "fr-FR").
+     * @see {@link Yop#setLocale}
+     */
+    static setLocale(locale: string): void;
+    /**
+     * Gets the message provider for the current locale. This message provider is used to retrieve localized validation messages based on the current locale setting.
+     */
+    get messageProvider(): MessageProvider;
+    /**
+     * Initializes the Yop instance if it hasn't been initialized yet and returns the default instance.
+     * @returns The default Yop instance.
+     */
+    static init(): Yop;
+}
+
+export { }