@owanturist/signal-form 0.0.0 → 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,954 @@
+import * as _owanturist_signal from '@owanturist/signal';
+import { ReadonlySignal, Monitor, Signal, Equal } from '@owanturist/signal';
+
+type Result<TError, TData> = [TError, null] | [null, TData];
+
+type ValidateStrategy = "onTouch" | "onChange" | "onSubmit" | "onInit";
+declare const VALIDATE_ON_TOUCH: "onTouch";
+declare const VALIDATE_ON_CHANGE: "onChange";
+declare const VALIDATE_ON_SUBMIT: "onSubmit";
+declare const VALIDATE_ON_INIT: "onInit";
+
+interface SignalFormParams {
+    readonly "input.setter": unknown;
+    readonly "input.schema": unknown;
+    readonly "output.schema": unknown;
+    readonly "output.schema.verbose": unknown;
+    readonly "flag.setter": unknown;
+    readonly "flag.schema": unknown;
+    readonly "flag.schema.verbose": unknown;
+    readonly "validateOn.setter": unknown;
+    readonly "validateOn.schema": unknown;
+    readonly "validateOn.schema.verbose": unknown;
+    readonly "error.setter": unknown;
+    readonly "error.schema": unknown;
+    readonly "error.schema.verbose": unknown;
+}
+
+declare class Emitter<TPayload = unknown, TResult = void> {
+    private readonly _listeners;
+    _subscribe(listener: (payload: TPayload) => TResult): VoidFunction;
+    _emit(payload: TPayload): ReadonlyArray<TResult>;
+    _isEmpty(): boolean;
+}
+
+type Lazy<T> = () => T;
+declare function Lazy<T>(init: () => T): Lazy<T>;
+
+declare abstract class SignalFormState<TParams extends SignalFormParams = any> {
+    abstract readonly _host: Lazy<SignalForm<TParams>>;
+    readonly _root: SignalFormState;
+    constructor(parent: null | SignalFormState);
+    protected abstract _childOf(parent: null | SignalFormState): SignalFormState<TParams>;
+    _clone(): SignalFormState<TParams>;
+    _parentOf<TChild extends SignalFormState>(child: TChild): TChild;
+    _hasSameRootWith(another: SignalFormState): boolean;
+    abstract readonly _initial: ReadonlySignal<TParams["input.schema"]>;
+    abstract _replaceInitial(monitor: Monitor, state: undefined | this, isMounting: boolean): void;
+    abstract _setInitial(monitor: Monitor, setter: TParams["input.setter"]): void;
+    abstract readonly _input: ReadonlySignal<TParams["input.schema"]>;
+    abstract _setInput(monitor: Monitor, setter: TParams["input.setter"]): void;
+    abstract readonly _error: ReadonlySignal<null | TParams["error.schema"]>;
+    abstract readonly _errorVerbose: ReadonlySignal<TParams["error.schema.verbose"]>;
+    abstract _setError(monitor: Monitor, setter: TParams["error.setter"]): void;
+    abstract readonly _validateOn: ReadonlySignal<TParams["validateOn.schema"]>;
+    abstract readonly _validateOnVerbose: ReadonlySignal<TParams["validateOn.schema.verbose"]>;
+    abstract _setValidateOn(monitor: Monitor, setter: TParams["validateOn.setter"]): void;
+    abstract readonly _touched: ReadonlySignal<TParams["flag.schema"]>;
+    abstract readonly _touchedVerbose: ReadonlySignal<TParams["flag.schema.verbose"]>;
+    abstract _setTouched(monitor: Monitor, setter: TParams["flag.setter"]): void;
+    abstract readonly _output: ReadonlySignal<null | TParams["output.schema"]>;
+    abstract readonly _outputVerbose: ReadonlySignal<TParams["output.schema.verbose"]>;
+    abstract readonly _valid: ReadonlySignal<TParams["flag.schema"]>;
+    abstract readonly _validVerbose: ReadonlySignal<TParams["flag.schema.verbose"]>;
+    abstract readonly _invalid: ReadonlySignal<TParams["flag.schema"]>;
+    abstract readonly _invalidVerbose: ReadonlySignal<TParams["flag.schema.verbose"]>;
+    abstract readonly _validated: ReadonlySignal<TParams["flag.schema"]>;
+    abstract readonly _validatedVerbose: ReadonlySignal<TParams["flag.schema.verbose"]>;
+    abstract _forceValidated(monitor: Monitor): void;
+    abstract readonly _dirty: ReadonlySignal<TParams["flag.schema"]>;
+    abstract readonly _dirtyVerbose: ReadonlySignal<TParams["flag.schema.verbose"]>;
+    abstract readonly _dirtyOn: ReadonlySignal<TParams["flag.schema"]>;
+    abstract readonly _dirtyOnVerbose: ReadonlySignal<TParams["flag.schema.verbose"]>;
+    readonly _onFocus: Emitter<unknown, void>;
+    _getFocusFirstInvalid(monitor: Monitor): null | VoidFunction;
+    readonly _onSubmit: Emitter<unknown, void | Promise<unknown>>;
+    readonly _submitAttempts: Signal<number>;
+    readonly _submittingCount: Signal<number>;
+    _submitWith(monitor: Monitor, output: TParams["output.schema"]): ReadonlyArray<void | Promise<unknown>>;
+    /**
+     * Comparing to {@link _setInitial} where the setter is always provided,
+     * this method allows the resetter to be undefined.
+     * This is for cases when the initial value is not changed BUT
+     * the {@link SignalForm} should perform the rest of reset operations,
+     * in comparison to {@link _setInitial} which only sets the initial value AND
+     * not called at all if the setter is not provided.
+     */
+    abstract _reset(monitor: Monitor, resetter: undefined | TParams["input.setter"]): void;
+    abstract _getChildren<TChildParams extends SignalFormParams>(monitor: Monitor): ReadonlyArray<SignalFormChild<TChildParams, TParams>>;
+}
+interface SignalFormChild<TChildParams extends SignalFormParams, TParams extends SignalFormParams> {
+    _state: SignalFormState<TChildParams>;
+    _mapToChild(this: void, parentValue: TParams["output.schema"]): TChildParams["output.schema"];
+}
+
+declare abstract class SignalForm<TParams extends SignalFormParams = any> {
+    protected static _getState<TFormParams extends SignalFormParams>({ _state, }: SignalForm<TFormParams>): SignalFormState<TFormParams>;
+    protected abstract readonly _state: SignalFormState<TParams>;
+    clone(): SignalForm<TParams>;
+    getOutput(monitor: Monitor): null | TParams["output.schema"];
+    getOutput<TResult>(monitor: Monitor, select: (concise: null | TParams["output.schema"], verbose: TParams["output.schema.verbose"]) => TResult): TResult;
+    getInitial(monitor: Monitor): TParams["input.schema"];
+    setInitial(setter: TParams["input.setter"]): void;
+    getInput(monitor: Monitor): TParams["input.schema"];
+    setInput(setter: TParams["input.setter"]): void;
+    getError(monitor: Monitor): null | TParams["error.schema"];
+    getError<TResult>(monitor: Monitor, select: (concise: null | TParams["error.schema"], verbose: TParams["error.schema.verbose"]) => TResult): TResult;
+    setError(setter: TParams["error.setter"]): void;
+    getValidateOn(monitor: Monitor): TParams["validateOn.schema"];
+    getValidateOn<TResult>(monitor: Monitor, select: (concise: TParams["validateOn.schema"], verbose: TParams["validateOn.schema.verbose"]) => TResult): TResult;
+    setValidateOn(setter: TParams["validateOn.setter"]): void;
+    isValid(monitor: Monitor): boolean;
+    isValid<TResult>(monitor: Monitor, select: (concise: TParams["flag.schema"], verbose: TParams["flag.schema.verbose"]) => TResult): TResult;
+    isInvalid(monitor: Monitor): boolean;
+    isInvalid<TResult>(monitor: Monitor, select: (concise: TParams["flag.schema"], verbose: TParams["flag.schema.verbose"]) => TResult): TResult;
+    isValidated(monitor: Monitor): boolean;
+    isValidated<TResult>(monitor: Monitor, select: (concise: TParams["flag.schema"], verbose: TParams["flag.schema.verbose"]) => TResult): TResult;
+    isDirty(monitor: Monitor): boolean;
+    isDirty<TResult>(monitor: Monitor, select: (concise: TParams["flag.schema"], verbose: TParams["flag.schema.verbose"]) => TResult): TResult;
+    isTouched(monitor: Monitor): boolean;
+    isTouched<TResult>(monitor: Monitor, select: (concise: TParams["flag.schema"], verbose: TParams["flag.schema.verbose"]) => TResult): TResult;
+    setTouched(setter: TParams["flag.setter"]): void;
+    reset(resetter?: TParams["input.setter"]): void;
+    onFocusWhenInvalid(onFocus: (error: TParams["error.schema.verbose"]) => void): VoidFunction;
+    focusFirstInvalid(): void;
+    getSubmitCount(monitor: Monitor): number;
+    isSubmitting(monitor: Monitor): boolean;
+    onSubmit(listener: (output: TParams["output.schema"]) => void | Promise<unknown>): VoidFunction;
+    submit(): Promise<void>;
+}
+
+type GetSignalFormParams<TTarget> = TTarget extends SignalForm<infer TParams> ? TParams : never;
+
+type GetSignalFormParam<TTarget, TKey extends keyof SignalFormParams> = GetSignalFormParams<TTarget>[TKey];
+
+type GetSignalFormError<TForm extends SignalForm> = GetSignalFormParam<TForm, "error.schema">;
+
+type GetSignalFormErrorSetter<TForm extends SignalForm> = GetSignalFormParam<TForm, "error.setter">;
+
+type GetSignalFormErrorVerbose<TForm extends SignalForm> = GetSignalFormParam<TForm, "error.schema.verbose">;
+
+type GetSignalFormFlag<TForm extends SignalForm> = GetSignalFormParam<TForm, "flag.schema">;
+
+type GetSignalFormFlagSetter<TForm extends SignalForm> = GetSignalFormParam<TForm, "flag.setter">;
+
+type GetSignalFormFlagVerbose<TForm extends SignalForm> = GetSignalFormParam<TForm, "flag.schema.verbose">;
+
+type GetSignalFormInput<TForm extends SignalForm> = GetSignalFormParam<TForm, "input.schema">;
+
+type GetSignalFormInputSetter<TForm extends SignalForm> = GetSignalFormParam<TForm, "input.setter">;
+
+type GetSignalFormOutput<TForm extends SignalForm> = GetSignalFormParam<TForm, "output.schema">;
+
+type GetSignalFormOutputVerbose<TForm extends SignalForm> = GetSignalFormParam<TForm, "output.schema.verbose">;
+
+type GetSignalFormValidateOn<TForm extends SignalForm> = GetSignalFormParam<TForm, "validateOn.schema">;
+
+type GetSignalFormValidateOnSetter<TForm extends SignalForm> = GetSignalFormParam<TForm, "validateOn.setter">;
+
+type GetSignalFormValidateOnVerbose<TForm extends SignalForm> = GetSignalFormParam<TForm, "validateOn.schema.verbose">;
+
+declare function isSignalForm(value: unknown): value is SignalForm;
+
+type FormUnitTransformer<TInput, TOutput> = (input: TInput) => TOutput;
+
+type FormUnitValidator<TInput, TError, TOutput> = (input: TInput) => Result<TError, TOutput>;
+
+type Setter<TValue, TPrevValues extends ReadonlyArray<unknown> = [TValue]> = TValue | ((...args: TPrevValues) => TValue);
+
+type FormUnitErrorSetter<TError> = Setter<null | TError>;
+
+type FormUnitFlagSetter = Setter<boolean>;
+
+type FormUnitInputSetter<TInput> = Setter<TInput, [TInput, TInput]>;
+
+type FormUnitValidateOnSetter = Setter<ValidateStrategy>;
+
+interface FormUnitParams<TInput, TError, TOutput> extends SignalFormParams {
+    readonly "input.setter": FormUnitInputSetter<TInput>;
+    readonly "input.schema": TInput;
+    readonly "output.schema": TOutput;
+    readonly "output.schema.verbose": null | TOutput;
+    readonly "flag.setter": FormUnitFlagSetter;
+    readonly "flag.schema": boolean;
+    readonly "flag.schema.verbose": boolean;
+    readonly "validateOn.setter": FormUnitValidateOnSetter;
+    readonly "validateOn.schema": ValidateStrategy;
+    readonly "validateOn.schema.verbose": ValidateStrategy;
+    readonly "error.setter": FormUnitErrorSetter<TError>;
+    readonly "error.schema": null | TError;
+    readonly "error.schema.verbose": null | TError;
+}
+
+interface ZodLikeIssue {
+    message: string;
+}
+type ZodLikeError = {
+    get errors(): ReadonlyArray<ZodLikeIssue>;
+} | {
+    errors: ReadonlyArray<ZodLikeIssue>;
+} | {
+    issues: ReadonlyArray<ZodLikeIssue>;
+};
+type ZodLikeSafeParseResult<TOutput> = {
+    success: false;
+    error: ZodLikeError;
+} | {
+    success: true;
+    data: TOutput;
+};
+type ZodLikeSchema<TOutput> = {
+    parse(input: unknown): TOutput;
+} | {
+    safeParse(input: unknown): ZodLikeSafeParseResult<TOutput>;
+};
+declare function zodLikeParse<TOutput>(schema: ZodLikeSchema<TOutput>, input: unknown): Result<ReadonlyArray<string>, TOutput>;
+
+interface FormUnitTransform<TInput, TError, TOutput> {
+    readonly _transformer: boolean;
+    readonly _validator: FormUnitValidator<TInput, TError, TOutput>;
+}
+
+declare class FormUnitState<TInput, TError, TOutput> extends SignalFormState<FormUnitParams<TInput, TError, TOutput>> {
+    readonly _initialState: Signal<{
+        _explicit: Signal<boolean>;
+        _current: Signal<TInput>;
+    }>;
+    readonly _input: Signal<TInput>;
+    private readonly _customError;
+    readonly _validateOn: Signal<ValidateStrategy>;
+    readonly _touched: Signal<boolean>;
+    private readonly _transform;
+    private readonly _isInputDirty;
+    private readonly _isInputEqual;
+    private readonly _isOutputEqual;
+    private readonly _isErrorEqual;
+    readonly _host: Lazy<FormUnit$1<TInput, TError, TOutput>>;
+    constructor(parent: null | SignalFormState, _initialState: Signal<{
+        _explicit: Signal<boolean>;
+        _current: Signal<TInput>;
+    }>, _input: Signal<TInput>, _customError: Signal<null | TError>, _validateOn: Signal<ValidateStrategy>, _touched: Signal<boolean>, _transform: Signal<FormUnitTransform<TInput, TError, TOutput>>, _isInputDirty: Equal<TInput>, _isInputEqual: Equal<TInput>, _isOutputEqual: Equal<null | TOutput>, _isErrorEqual: Equal<null | TError>);
+    _childOf(parent: null | SignalFormState): FormUnitState<TInput, TError, TOutput>;
+    _initial: ReadonlySignal<TInput>;
+    _replaceInitial(monitor: Monitor, state: undefined | FormUnitState<TInput, TError, TOutput>, isMounting: boolean): void;
+    _setInitial(monitor: Monitor, setter: FormUnitInputSetter<TInput>): void;
+    _setInput(monitor: Monitor, setter: FormUnitInputSetter<TInput>): void;
+    readonly _error: ReadonlySignal<null | TError>;
+    readonly _errorVerbose: ReadonlySignal<null | TError>;
+    _setError(_monitor: Monitor, setter: FormUnitErrorSetter<TError>): void;
+    readonly _validateOnVerbose: ReadonlySignal<ValidateStrategy>;
+    _setValidateOn(monitor: Monitor, setter: FormUnitValidateOnSetter): void;
+    readonly _touchedVerbose: ReadonlySignal<boolean>;
+    _setTouched(_monitor: Monitor, setter: FormUnitParams<TInput, TError, TOutput>["flag.setter"]): void;
+    readonly _output: ReadonlySignal<null | TOutput>;
+    readonly _outputVerbose: ReadonlySignal<null | TOutput>;
+    readonly _valid: ReadonlySignal<boolean>;
+    readonly _validVerbose: ReadonlySignal<boolean>;
+    readonly _invalid: ReadonlySignal<boolean>;
+    readonly _invalidVerbose: ReadonlySignal<boolean>;
+    readonly _validated: Signal<boolean>;
+    readonly _validatedVerbose: ReadonlySignal<boolean>;
+    _forceValidated(): void;
+    readonly _dirty: ReadonlySignal<boolean>;
+    readonly _dirtyVerbose: ReadonlySignal<boolean>;
+    readonly _dirtyOn: Signal<boolean>;
+    readonly _dirtyOnVerbose: Signal<boolean>;
+    _reset(monitor: Monitor, resetter: undefined | FormUnitInputSetter<TInput>): void;
+    _getChildren(): ReadonlyArray<never>;
+    _setTransform(transformer: FormUnitTransformer<TInput, TOutput>): void;
+}
+
+declare class FormUnit$1<TInput, TError, TOutput> extends SignalForm<FormUnitParams<TInput, TError, TOutput>> {
+    readonly _state: FormUnitState<TInput, TError, TOutput>;
+    constructor(_state: FormUnitState<TInput, TError, TOutput>);
+    setTransform(transformer: FormUnitTransformer<TInput, TOutput>): void;
+}
+
+interface FormUnitOptions<TInput, TError = null> {
+    /**
+     * The initial or custom error associated with the form value.
+     * This can be used to set an error state manually.
+     *
+     * @default null
+     */
+    readonly error?: null | TError;
+    readonly touched?: boolean;
+    /**
+     * PERFORMANCE OPTIMIZATION
+     *
+     * A equality check function that determines whether the input value changes.
+     * When it does, the {@link SignalForm.getInput} returns the new value.
+     * Otherwise, it returns the previous value.
+     *
+     * Useful for none primitive values such as Objects, Arrays, Date, etc.
+     * Intended to improve performance but do not affect business logic.
+     *
+     * @default Object.is
+     *
+     * @example
+     * const initial = { count: 0 }
+     *
+     * const form = FormUnit(initial, {
+     *   isInputEqual: (left, right) => left.count === right.count,
+     * })
+     *
+     * form.setInput({ count: 0 })
+     * form.getInput(monitor) === initial // true
+     */
+    readonly isInputEqual?: Equal<TInput>;
+    /**
+     * BUSINESS LOGIC TUNING
+     *
+     * A equality check function that determines whether the input is dirty.
+     * When it is, the {@link SignalForm.isDirty} returns true.
+     * Fallbacks to not(isInputEqual) if not provided.
+     *
+     * Useful for values that have intermediate states deviating from the initial value,
+     * but should not be considered dirty such as strings, unsorted arrays, etc.
+     * Intended to tune business logic and avoid false positives for dirty states.
+     *
+     * @default not(isInputEqual)
+     *
+     * @example
+     * const form = FormUnit("", {
+     *   isInputDirty: (left, right) => left.trim() !== right.trim(),
+     * })
+     *
+     * form.setInput(" ")
+     * form.isDirty(monitor) === false
+     */
+    readonly isInputDirty?: Equal<TInput>;
+    /**
+     * PERFORMANCE OPTIMIZATION
+     *
+     * A equality check function that determines whether the validation error change.
+     * When it does, the {@link SignalForm.getError} returns the new value.
+     * Otherwise, it returns the previous value.
+     *
+     * Useful for none primitive values such as Objects, Arrays, Date, etc.
+     * Intended to improve performance but do not affect business logic.
+     *
+     * @default Object.is
+     */
+    readonly isErrorEqual?: Equal<TError>;
+    /**
+     * @default input
+     */
+    readonly initial?: TInput;
+}
+interface FormUnitTransformedOptions<TInput, TError = null, TOutput = TInput> extends Omit<FormUnitOptions<TInput, TError>, "isOutputEqual"> {
+    readonly transform: FormUnitTransformer<TInput, TOutput>;
+    /**
+     * PERFORMANCE OPTIMIZATION
+     *
+     * A equality check function that determines whether the output value changes.
+     * When it does, the {@link SignalForm.getOutput} returns the new value.
+     *
+     * Useful for none primitive values such as Objects, Arrays, Date, etc.
+     * Intended to improve performance but do not affect business logic.
+     *
+     * @default Object.is
+     */
+    readonly isOutputEqual?: Equal<TOutput>;
+}
+interface FormUnitSchemaOptions<TInput, TOutput = TInput> extends Omit<FormUnitTransformedOptions<TInput, ReadonlyArray<string>, TOutput>, "transform" | "isErrorEqual"> {
+    /**
+     * @default "onTouch"
+     */
+    readonly validateOn?: ValidateStrategy;
+    readonly schema: ZodLikeSchema<TOutput>;
+}
+interface FormUnitValidatedOptions<TInput, TError = null, TOutput = TInput> extends Omit<FormUnitTransformedOptions<TInput, TError, TOutput>, "transform"> {
+    /**
+     * @default "onTouch"
+     */
+    readonly validateOn?: ValidateStrategy;
+    readonly validate: FormUnitValidator<TInput, TError, TOutput>;
+}
+type FormUnit<TInput, TError = null, TOutput = TInput> = FormUnit$1<TInput, TError, TOutput>;
+declare function FormUnit<TInput, TError = null, TOutput = TInput>(input: TInput, options: FormUnitValidatedOptions<TInput, TError, TOutput> | FormUnitTransformedOptions<TInput, TError, TOutput>): FormUnit<TInput, TError, TOutput>;
+declare function FormUnit<TInput, TOutput = TInput>(input: TInput, options: FormUnitSchemaOptions<TInput, TOutput>): FormUnit<TInput, ReadonlyArray<string>, TOutput>;
+declare function FormUnit<TInput>(input: TInput, options?: FormUnitOptions<TInput>): FormUnit<TInput, null, TInput>;
+declare function FormUnit<TInput, TError>(input: TInput, options?: FormUnitOptions<TInput, TError>): FormUnit<TInput, TError, TInput>;
+
+declare function isFormUnit(value: unknown): value is FormUnit$1<unknown, unknown, unknown>;
+
+type FormShapeFields = Record<string, any>;
+
+type Compute<Obj> = unknown & {
+    [K in keyof Obj]: Obj[K];
+};
+
+type FilterKeys<TObject, TValue> = {
+    [K in keyof TObject]: TObject[K] extends TValue ? K : never;
+}[keyof TObject];
+
+type OmitValues<TObject, TValue> = Compute<Omit<TObject, FilterKeys<TObject, TValue>>>;
+
+type FallbackParamWhenNever<TKey extends keyof SignalFormParams, TFallback, TParam> = [
+    TParam
+] extends [never] ? TKey extends "input.schema" | "output.schema" | "output.schema.verbose" ? TFallback : never : TParam;
+type GetFormShapeParam<TFields extends FormShapeFields, TKey extends keyof SignalFormParams> = OmitValues<{
+    readonly [TField in keyof TFields]: FallbackParamWhenNever<TKey, TFields[TField], GetSignalFormParam<TFields[TField], TKey>>;
+}, never>;
+
+type FormShapeErrorVerbose<TFields extends FormShapeFields> = GetFormShapeParam<TFields, "error.schema.verbose">;
+
+type FormShapeErrorSetter<TFields extends FormShapeFields> = Setter<null | Partial<GetFormShapeParam<TFields, "error.setter">>, [
+    FormShapeErrorVerbose<TFields>
+]>;
+
+type FormShapeFlagVerbose<TFields extends FormShapeFields> = GetFormShapeParam<TFields, "flag.schema.verbose">;
+
+type FormShapeFlagSetter<TFields extends FormShapeFields> = Setter<boolean | Partial<GetFormShapeParam<TFields, "flag.setter">>, [
+    FormShapeFlagVerbose<TFields>
+]>;
+
+type FormShapeInput<TFields extends FormShapeFields> = GetFormShapeParam<TFields, "input.schema">;
+
+type FormShapeInputSetter<TFields extends FormShapeFields> = Setter<Partial<GetFormShapeParam<TFields, "input.setter">>, [
+    FormShapeInput<TFields>,
+    FormShapeInput<TFields>
+]>;
+
+type FormShapeValidateOnVerbose<TFields extends FormShapeFields> = GetFormShapeParam<TFields, "validateOn.schema.verbose">;
+
+type FormShapeValidateOnSetter<TFields extends FormShapeFields> = Setter<ValidateStrategy | Partial<GetFormShapeParam<TFields, "validateOn.setter">>, [
+    FormShapeValidateOnVerbose<TFields>
+]>;
+
+type FormMeta<TValue> = (monitor: Monitor) => TValue;
+
+type FormShapeError<TFields extends FormShapeFields> = null | GetFormShapeParam<TFields, "error.schema">;
+
+type FormShapeFlag<TFields extends FormShapeFields> = boolean | GetFormShapeParam<TFields, "flag.schema">;
+
+type FormShapeOutput<TFields extends FormShapeFields> = GetFormShapeParam<TFields, "output.schema">;
+
+type FormShapeOutputVerbose<TFields extends FormShapeFields> = GetFormShapeParam<TFields, "output.schema.verbose">;
+
+type FormShapeValidateOn<TFields extends FormShapeFields> = ValidateStrategy | GetFormShapeParam<TFields, "validateOn.schema">;
+
+interface FormShapeParams<TFields extends FormShapeFields> extends SignalFormParams {
+    readonly "input.schema": FormShapeInput<TFields>;
+    readonly "input.setter": FormShapeInputSetter<TFields>;
+    readonly "output.schema": FormShapeOutput<TFields>;
+    readonly "output.schema.verbose": FormShapeOutputVerbose<TFields>;
+    readonly "flag.setter": FormShapeFlagSetter<TFields>;
+    readonly "flag.schema": FormShapeFlag<TFields>;
+    readonly "flag.schema.verbose": FormShapeFlagVerbose<TFields>;
+    readonly "validateOn.setter": FormShapeValidateOnSetter<TFields>;
+    readonly "validateOn.schema": FormShapeValidateOn<TFields>;
+    readonly "validateOn.schema.verbose": FormShapeValidateOnVerbose<TFields>;
+    readonly "error.setter": FormShapeErrorSetter<TFields>;
+    readonly "error.schema": FormShapeError<TFields>;
+    readonly "error.schema.verbose": FormShapeErrorVerbose<TFields>;
+}
+
+type FormShapeStateFields<TFields extends FormShapeFields> = OmitValues<{
+    [TField in keyof TFields]: TFields[TField] extends SignalForm<infer TParams> ? SignalFormState<TParams> : never;
+}, never>;
+type FormShapeStateMeta<TFields extends FormShapeFields> = OmitValues<{
+    [TField in keyof TFields]: TFields[TField] extends SignalForm ? never : Signal<TFields[TField]>;
+}, never>;
+declare class FormShapeState<TFields extends FormShapeFields = FormShapeFields> extends SignalFormState<FormShapeParams<TFields>> {
+    readonly _host: Lazy<FormShape$1<TFields>>;
+    readonly _fields: FormShapeStateFields<TFields>;
+    readonly _meta: FormShapeStateMeta<TFields>;
+    constructor(parent: null | SignalFormState, fields: FormShapeStateFields<TFields>, meta: FormShapeStateMeta<TFields>);
+    _childOf(parent: null | SignalFormState): FormShapeState<TFields>;
+    readonly _initial: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "input.schema">] extends [never] ? TFields[TField] : GetSignalFormParam<TFields[TField], "input.schema">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "input.schema">] extends [never] ? TFields[TField] : GetSignalFormParam<TFields[TField], "input.schema">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    _replaceInitial(monitor: Monitor, state: undefined | FormShapeState<TFields>, isMounting: boolean): void;
+    _setInitial(monitor: Monitor, setter: FormShapeInputSetter<TFields>): void;
+    readonly _input: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "input.schema">] extends [never] ? TFields[TField] : GetSignalFormParam<TFields[TField], "input.schema">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "input.schema">] extends [never] ? TFields[TField] : GetSignalFormParam<TFields[TField], "input.schema">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    _setInput(monitor: Monitor, setter: FormShapeInputSetter<TFields>): void;
+    readonly _error: _owanturist_signal.ReadonlySignal<FormShapeError<TFields>>;
+    readonly _errorVerbose: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "error.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "error.schema.verbose">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "error.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "error.schema.verbose">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    _setError(monitor: Monitor, setter: FormShapeErrorSetter<TFields>): void;
+    readonly _validateOn: _owanturist_signal.ReadonlySignal<FormShapeValidateOn<TFields>>;
+    readonly _validateOnVerbose: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "validateOn.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "validateOn.schema.verbose">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "validateOn.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "validateOn.schema.verbose">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    _setValidateOn(monitor: Monitor, setter: FormShapeValidateOnSetter<TFields>): void;
+    readonly _touched: _owanturist_signal.ReadonlySignal<FormShapeFlag<TFields>>;
+    readonly _touchedVerbose: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    _setTouched(monitor: Monitor, setter: FormShapeFlagSetter<TFields>): void;
+    readonly _output: _owanturist_signal.ReadonlySignal<(Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "output.schema">] extends [never] ? TFields[TField] : GetSignalFormParam<TFields[TField], "output.schema">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "output.schema">] extends [never] ? TFields[TField] : GetSignalFormParam<TFields[TField], "output.schema">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never) | null>;
+    readonly _outputVerbose: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "output.schema.verbose">] extends [never] ? TFields[TField] : GetSignalFormParam<TFields[TField], "output.schema.verbose">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "output.schema.verbose">] extends [never] ? TFields[TField] : GetSignalFormParam<TFields[TField], "output.schema.verbose">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    readonly _valid: _owanturist_signal.ReadonlySignal<FormShapeFlag<TFields>>;
+    readonly _validVerbose: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    readonly _invalid: _owanturist_signal.ReadonlySignal<FormShapeFlag<TFields>>;
+    readonly _invalidVerbose: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    readonly _validated: _owanturist_signal.ReadonlySignal<FormShapeFlag<TFields>>;
+    readonly _validatedVerbose: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    _forceValidated(monitor: Monitor): void;
+    readonly _dirty: _owanturist_signal.ReadonlySignal<FormShapeFlag<TFields>>;
+    readonly _dirtyVerbose: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    readonly _dirtyOn: _owanturist_signal.ReadonlySignal<FormShapeFlag<TFields>>;
+    readonly _dirtyOnVerbose: _owanturist_signal.ReadonlySignal<Omit<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, FilterKeys<{ readonly [TField in keyof TFields]: [GetSignalFormParam<TFields[TField], "flag.schema.verbose">] extends [never] ? never : GetSignalFormParam<TFields[TField], "flag.schema.verbose">; }, never>> extends infer T ? { [K in keyof T]: T[K]; } : never>;
+    _reset(monitor: Monitor, resetter: undefined | FormShapeInputSetter<TFields>): void;
+    _getChildren<TChildParams extends SignalFormParams>(): ReadonlyArray<SignalFormChild<TChildParams, FormShapeParams<TFields>>>;
+}
+
+type FormShapeField<TField> = TField extends SignalForm ? TField : FormMeta<TField>;
+declare class FormShape$1<TFields extends FormShapeFields> extends SignalForm<FormShapeParams<TFields>> {
+    readonly _state: FormShapeState<TFields>;
+    static _getState: typeof SignalForm._getState;
+    readonly fields: {
+        readonly [TField in keyof TFields]: FormShapeField<TFields[TField]>;
+    };
+    constructor(_state: FormShapeState<TFields>);
+}
+
+interface FormShapeOptions<TFields extends FormShapeFields> {
+    readonly input?: FormShapeInputSetter<TFields>;
+    readonly initial?: FormShapeInputSetter<TFields>;
+    readonly touched?: FormShapeFlagSetter<TFields>;
+    readonly validateOn?: FormShapeValidateOnSetter<TFields>;
+    readonly error?: FormShapeErrorSetter<TFields>;
+}
+type FormShape<TFields extends FormShapeFields> = FormShape$1<TFields>;
+declare function FormShape<TFields extends FormShapeFields>(fields: TFields, { input, initial, touched, validateOn, error }?: FormShapeOptions<TFields>): FormShape<TFields>;
+
+declare function isFormShape(value: unknown): value is FormShape$1<FormShapeFields>;
+
+type FormListErrorVerbose<TElement extends SignalForm> = ReadonlyArray<GetSignalFormErrorVerbose<TElement>>;
+
+type FormListErrorSetter<TElement extends SignalForm> = Setter<null | ReadonlyArray<undefined | GetSignalFormErrorSetter<TElement>>, [
+    FormListErrorVerbose<TElement>
+]>;
+
+type FormListFlagVerbose<TElement extends SignalForm> = ReadonlyArray<GetSignalFormFlagVerbose<TElement>>;
+
+type FormListFlagSetter<TElement extends SignalForm> = Setter<boolean | ReadonlyArray<undefined | GetSignalFormFlagSetter<TElement>>, [
+    FormListFlagVerbose<TElement>
+]>;
+
+type FormListInput<TElement extends SignalForm> = ReadonlyArray<GetSignalFormInput<TElement>>;
+
+type FormListInputSetter<TElement extends SignalForm> = Setter<ReadonlyArray<undefined | GetSignalFormInputSetter<TElement>>, [
+    FormListInput<TElement>,
+    FormListInput<TElement>
+]>;
+
+type FormListValidateOnVerbose<TElement extends SignalForm> = ReadonlyArray<GetSignalFormValidateOnVerbose<TElement>>;
+
+type FormListValidateOnSetter<TElement extends SignalForm> = Setter<ValidateStrategy | ReadonlyArray<undefined | GetSignalFormValidateOnSetter<TElement>>, [
+    FormListValidateOnVerbose<TElement>
+]>;
+
+type FormListError<TElement extends SignalForm> = null | ReadonlyArray<GetSignalFormError<TElement>>;
+
+type FormListFlag<TElement extends SignalForm> = boolean | ReadonlyArray<GetSignalFormFlag<TElement>>;
+
+type FormListOutput<TElement extends SignalForm> = ReadonlyArray<GetSignalFormOutput<TElement>>;
+
+type FormListOutputVerbose<TElement extends SignalForm> = ReadonlyArray<GetSignalFormOutputVerbose<TElement>>;
+
+type FormListValidateOn<TElement extends SignalForm> = ValidateStrategy | ReadonlyArray<GetSignalFormValidateOn<TElement>>;
+
+interface FormListParams<TElement extends SignalForm> extends SignalFormParams {
+    "input.schema": FormListInput<TElement>;
+    "input.setter": FormListInputSetter<TElement>;
+    "output.schema": FormListOutput<TElement>;
+    "output.schema.verbose": FormListOutputVerbose<TElement>;
+    "flag.setter": FormListFlagSetter<TElement>;
+    "flag.schema": FormListFlag<TElement>;
+    "flag.schema.verbose": FormListFlagVerbose<TElement>;
+    "validateOn.setter": FormListValidateOnSetter<TElement>;
+    "validateOn.schema": FormListValidateOn<TElement>;
+    "validateOn.schema.verbose": FormListValidateOnVerbose<TElement>;
+    "error.setter": FormListErrorSetter<TElement>;
+    "error.schema": FormListError<TElement>;
+    "error.schema.verbose": FormListErrorVerbose<TElement>;
+}
+
+declare class FormListState<TElement extends SignalForm = SignalForm> extends SignalFormState<FormListParams<TElement>> {
+    readonly _host: Lazy<FormList$1<TElement>>;
+    readonly _elements: Signal<ReadonlyArray<SignalFormState<GetSignalFormParams<TElement>>>>;
+    private readonly _initialElements;
+    constructor(parent: null | SignalFormState, elements: ReadonlyArray<SignalFormState<GetSignalFormParams<TElement>>>);
+    _childOf(parent: null | SignalFormState): FormListState<TElement>;
+    _getElements(monitor: Monitor): ReadonlyArray<TElement>;
+    _getInitialElements(monitor: Monitor): ReadonlyArray<SignalFormState<GetSignalFormParams<TElement>>>;
+    readonly _initial: _owanturist_signal.ReadonlySignal<FormListInput<TElement>>;
+    _replaceInitial(monitor: Monitor, state: undefined | FormListState<TElement>, isMounting: boolean): void;
+    _setInitial(monitor: Monitor, setter: FormListInputSetter<TElement>): void;
+    readonly _input: _owanturist_signal.ReadonlySignal<FormListInput<TElement>>;
+    _setInput(monitor: Monitor, setter: FormListInputSetter<TElement>): void;
+    readonly _error: _owanturist_signal.ReadonlySignal<FormListError<TElement>>;
+    readonly _errorVerbose: _owanturist_signal.ReadonlySignal<FormListErrorVerbose<TElement>>;
+    _setError(monitor: Monitor, setter: FormListErrorSetter<TElement>): void;
+    readonly _validateOn: _owanturist_signal.ReadonlySignal<FormListValidateOn<TElement>>;
+    readonly _validateOnVerbose: _owanturist_signal.ReadonlySignal<FormListValidateOnVerbose<TElement>>;
+    _setValidateOn(monitor: Monitor, setter: FormListValidateOnSetter<TElement>): void;
+    readonly _touched: _owanturist_signal.ReadonlySignal<FormListFlag<TElement>>;
+    readonly _touchedVerbose: _owanturist_signal.ReadonlySignal<FormListFlagVerbose<TElement>>;
+    _setTouched(monitor: Monitor, setter: FormListFlagSetter<TElement>): void;
+    readonly _output: _owanturist_signal.ReadonlySignal<FormListOutput<TElement> | null>;
+    readonly _outputVerbose: _owanturist_signal.ReadonlySignal<FormListOutputVerbose<TElement>>;
+    readonly _valid: _owanturist_signal.ReadonlySignal<FormListFlag<TElement>>;
+    readonly _validVerbose: _owanturist_signal.ReadonlySignal<FormListFlagVerbose<TElement>>;
+    readonly _invalid: _owanturist_signal.ReadonlySignal<FormListFlag<TElement>>;
+    readonly _invalidVerbose: _owanturist_signal.ReadonlySignal<FormListFlagVerbose<TElement>>;
+    readonly _validated: _owanturist_signal.ReadonlySignal<FormListFlag<TElement>>;
+    readonly _validatedVerbose: _owanturist_signal.ReadonlySignal<FormListFlagVerbose<TElement>>;
+    _forceValidated(monitor: Monitor): void;
+    readonly _dirty: _owanturist_signal.ReadonlySignal<FormListFlag<TElement>>;
+    readonly _dirtyVerbose: _owanturist_signal.ReadonlySignal<FormListFlagVerbose<TElement>>;
+    readonly _dirtyOn: _owanturist_signal.ReadonlySignal<FormListFlag<TElement>>;
+    readonly _dirtyOnVerbose: _owanturist_signal.ReadonlySignal<FormListFlagVerbose<TElement>>;
+    _reset(monitor: Monitor, resetter: undefined | FormListInputSetter<TElement>): void;
+    _getChildren<TChildParams extends SignalFormParams>(monitor: Monitor): ReadonlyArray<SignalFormChild<TChildParams, FormListParams<TElement>>>;
+}
+
+declare class FormList$1<TElement extends SignalForm> extends SignalForm<FormListParams<TElement>> {
+    readonly _state: FormListState<TElement>;
+    static _getState: typeof SignalForm._getState;
+    private readonly _elements;
+    constructor(_state: FormListState<TElement>);
+    getElements(monitor: Monitor): ReadonlyArray<TElement>;
+    getElements<TResult>(monitor: Monitor, select: (elements: ReadonlyArray<TElement>) => TResult): TResult;
+    setElements(setter: Setter<ReadonlyArray<TElement>, [ReadonlyArray<TElement>, Monitor]>): void;
+}
+
+interface FormListOptions<TElement extends SignalForm> {
+    readonly input?: FormListInputSetter<TElement>;
+    readonly initial?: FormListInputSetter<TElement>;
+    readonly touched?: FormListFlagSetter<TElement>;
+    readonly validateOn?: FormListValidateOnSetter<TElement>;
+    readonly error?: FormListErrorSetter<TElement>;
+}
+type FormList<TElement extends SignalForm> = FormList$1<TElement>;
+declare function FormList<TElement extends SignalForm>(elements: ReadonlyArray<TElement>, { input, initial, touched, validateOn, error }?: FormListOptions<TElement>): FormList<TElement>;
+
+declare function isFormList(value: unknown): value is FormList$1<SignalForm>;
+
+type IsEqualType<TLeft, TRight> = [TLeft, TRight] extends [TRight, TLeft] ? true : false;
+
+interface FormOptionalSchema<TEnabled, TElement> {
+    readonly enabled: TEnabled;
+    readonly element: TElement;
+}
+
+type FormOptionalParam<TEnabled extends SignalForm, TElement extends SignalForm, TKey extends keyof SignalFormParams, TConcise = never> = TConcise | FormOptionalSchema<TConcise | GetSignalFormParam<TEnabled, TKey>, TConcise | GetSignalFormParam<TElement, TKey>>;
+
+type FormOptionalErrorVerbose<TEnabled extends SignalForm, TElement extends SignalForm> = FormOptionalParam<TEnabled, TElement, "error.schema.verbose">;
+
+type FormOptionalErrorSetter<TEnabled extends SignalForm, TElement extends SignalForm> = Setter<null | Partial<FormOptionalSchema<GetSignalFormParam<TEnabled, "error.setter">, GetSignalFormParam<TElement, "error.setter">>>, [
+    FormOptionalErrorVerbose<TEnabled, TElement>
+]>;
+
+type FormOptionalFlagVerbose<TEnabled extends SignalForm, TElement extends SignalForm> = FormOptionalParam<TEnabled, TElement, "flag.schema.verbose">;
+
+type FormOptionalFlagSetter<TEnabled extends SignalForm, TElement extends SignalForm> = Setter<boolean | Partial<FormOptionalSchema<GetSignalFormParam<TEnabled, "flag.setter">, GetSignalFormParam<TElement, "flag.setter">>>, [
+    FormOptionalFlagVerbose<TEnabled, TElement>
+]>;
+
+type FormOptionalInput<TEnabled extends SignalForm, TElement extends SignalForm> = FormOptionalSchema<GetSignalFormParam<TEnabled, "input.schema">, GetSignalFormParam<TElement, "input.schema">>;
+
+type FormOptionalInputSetter<TEnabled extends SignalForm, TElement extends SignalForm> = Setter<Partial<FormOptionalSchema<GetSignalFormParam<TEnabled, "input.setter">, GetSignalFormParam<TElement, "input.setter">>>, [
+    FormOptionalInput<TEnabled, TElement>,
+    FormOptionalInput<TEnabled, TElement>
+]>;
+
+type FormOptionalValidateOnVerbose<TEnabled extends SignalForm, TElement extends SignalForm> = FormOptionalParam<TEnabled, TElement, "validateOn.schema.verbose">;
+
+type FormOptionalValidateOnSetter<TEnabled extends SignalForm, TElement extends SignalForm> = Setter<ValidateStrategy | Partial<FormOptionalSchema<GetSignalFormParam<TEnabled, "validateOn.setter">, GetSignalFormParam<TElement, "validateOn.setter">>>, [
+    FormOptionalValidateOnVerbose<TEnabled, TElement>
+]>;
+
+type FormOptionalError<TEnabled extends SignalForm, TElement extends SignalForm> = FormOptionalParam<TEnabled, TElement, "error.schema", null>;
+
+type FormOptionalFlag<TEnabled extends SignalForm, TElement extends SignalForm> = FormOptionalParam<TEnabled, TElement, "flag.schema", boolean>;
+
+type FormOptionalOutput<TElement extends SignalForm> = undefined | GetSignalFormParam<TElement, "output.schema">;
+
+type FormOptionalOutputVerbose<TEnabled extends SignalForm, TElement extends SignalForm> = FormOptionalParam<TEnabled, TElement, "output.schema.verbose">;
+
+type FormOptionalValidateOn<TEnabled extends SignalForm, TElement extends SignalForm> = FormOptionalParam<TEnabled, TElement, "validateOn.schema", ValidateStrategy>;
+
+interface FormOptionalParams<TEnabled extends SignalForm, TElement extends SignalForm> extends SignalFormParams {
+    "input.schema": FormOptionalInput<TEnabled, TElement>;
+    "input.setter": FormOptionalInputSetter<TEnabled, TElement>;
+    "output.schema": FormOptionalOutput<TElement>;
+    "output.schema.verbose": FormOptionalOutputVerbose<TEnabled, TElement>;
+    "flag.setter": FormOptionalFlagSetter<TEnabled, TElement>;
+    "flag.schema": FormOptionalFlag<TEnabled, TElement>;
+    "flag.schema.verbose": FormOptionalFlagVerbose<TEnabled, TElement>;
+    "validateOn.setter": FormOptionalValidateOnSetter<TEnabled, TElement>;
+    "validateOn.schema": FormOptionalValidateOn<TEnabled, TElement>;
+    "validateOn.schema.verbose": FormOptionalValidateOnVerbose<TEnabled, TElement>;
+    "error.setter": FormOptionalErrorSetter<TEnabled, TElement>;
+    "error.schema": FormOptionalError<TEnabled, TElement>;
+    "error.schema.verbose": FormOptionalErrorVerbose<TEnabled, TElement>;
+}
+
+declare class FormOptionalState<TEnabled extends SignalForm, TElement extends SignalForm> extends SignalFormState<FormOptionalParams<TEnabled, TElement>> {
+    readonly _host: Lazy<FormOptional$1<TEnabled, TElement>>;
+    readonly _enabled: SignalFormState<GetSignalFormParams<TEnabled>>;
+    readonly _element: SignalFormState<GetSignalFormParams<TElement>>;
+    constructor(parent: null | SignalFormState, enabled: SignalFormState<GetSignalFormParams<TEnabled>>, element: SignalFormState<GetSignalFormParams<TElement>>);
+    private _isEnabled;
+    _getEnabledElement(monitor: Monitor): undefined | SignalFormState<GetSignalFormParams<TElement>>;
+    _childOf(parent: null | SignalFormState): FormOptionalState<TEnabled, TElement>;
+    private _toConcise;
+    private _toVerbose;
+    readonly _initial: _owanturist_signal.ReadonlySignal<FormOptionalInput<TEnabled, TElement>>;
+    _setInitial(monitor: Monitor, setter: FormOptionalInputSetter<TEnabled, TElement>): void;
+    _replaceInitial(monitor: Monitor, state: undefined | FormOptionalState<TEnabled, TElement>, isMounting: boolean): void;
+    readonly _input: _owanturist_signal.ReadonlySignal<FormOptionalInput<TEnabled, TElement>>;
+    _setInput(monitor: Monitor, setter: FormOptionalInputSetter<TEnabled, TElement>): void;
+    readonly _error: _owanturist_signal.ReadonlySignal<FormOptionalError<TEnabled, TElement>>;
+    readonly _errorVerbose: _owanturist_signal.ReadonlySignal<FormOptionalErrorVerbose<TEnabled, TElement>>;
+    _setError(monitor: Monitor, setter: FormOptionalErrorSetter<TEnabled, TElement>): void;
+    readonly _validateOn: _owanturist_signal.ReadonlySignal<FormOptionalValidateOn<TEnabled, TElement>>;
+    readonly _validateOnVerbose: _owanturist_signal.ReadonlySignal<FormOptionalValidateOnVerbose<TEnabled, TElement>>;
+    _setValidateOn(monitor: Monitor, setter: FormOptionalValidateOnSetter<TEnabled, TElement>): void;
+    readonly _touched: _owanturist_signal.ReadonlySignal<FormOptionalFlag<TEnabled, TElement>>;
+    readonly _touchedVerbose: _owanturist_signal.ReadonlySignal<FormOptionalFlagVerbose<TEnabled, TElement>>;
+    _setTouched(monitor: Monitor, setter: FormOptionalFlagSetter<TEnabled, TElement>): void;
+    readonly _output: _owanturist_signal.ReadonlySignal<FormOptionalOutput<TElement> | null>;
+    readonly _outputVerbose: _owanturist_signal.ReadonlySignal<FormOptionalOutputVerbose<TEnabled, TElement>>;
+    readonly _valid: _owanturist_signal.ReadonlySignal<FormOptionalFlag<TEnabled, TElement>>;
+    readonly _validVerbose: _owanturist_signal.ReadonlySignal<FormOptionalFlagVerbose<TEnabled, TElement>>;
+    readonly _invalid: _owanturist_signal.ReadonlySignal<FormOptionalFlag<TEnabled, TElement>>;
+    readonly _invalidVerbose: _owanturist_signal.ReadonlySignal<FormOptionalFlagVerbose<TEnabled, TElement>>;
+    readonly _validated: _owanturist_signal.ReadonlySignal<FormOptionalFlag<TEnabled, TElement>>;
+    readonly _validatedVerbose: _owanturist_signal.ReadonlySignal<FormOptionalFlagVerbose<TEnabled, TElement>>;
+    _forceValidated(monitor: Monitor): void;
+    readonly _dirty: _owanturist_signal.ReadonlySignal<FormOptionalFlag<TEnabled, TElement>>;
+    readonly _dirtyVerbose: _owanturist_signal.ReadonlySignal<FormOptionalFlagVerbose<TEnabled, TElement>>;
+    readonly _dirtyOn: _owanturist_signal.ReadonlySignal<FormOptionalFlag<TEnabled, TElement>>;
+    readonly _dirtyOnVerbose: _owanturist_signal.ReadonlySignal<FormOptionalFlagVerbose<TEnabled, TElement>>;
+    _reset(monitor: Monitor, resetter: undefined | FormOptionalInputSetter<TEnabled, TElement>): void;
+    _getChildren<TChildParams extends SignalFormParams>(monitor: Monitor): ReadonlyArray<SignalFormChild<TChildParams, FormOptionalParams<TEnabled, TElement>>>;
+}
+
+declare class FormOptional$1<TEnabled extends SignalForm, TElement extends SignalForm> extends SignalForm<FormOptionalParams<TEnabled, TElement>> {
+    readonly _state: FormOptionalState<TEnabled, TElement>;
+    static _getState: typeof SignalForm._getState;
+    readonly enabled: TEnabled;
+    readonly element: TElement;
+    constructor(_state: FormOptionalState<TEnabled, TElement>);
+    getEnabledElement(monitor: Monitor): undefined | TElement;
+}
+
+interface FormOptionalOptions<TEnabled extends SignalForm, TElement extends SignalForm> {
+    input?: FormOptionalInputSetter<TEnabled, TElement>;
+    initial?: FormOptionalInputSetter<TEnabled, TElement>;
+    touched?: FormOptionalFlagSetter<TEnabled, TElement>;
+    validateOn?: FormOptionalValidateOnSetter<TEnabled, TElement>;
+    error?: FormOptionalErrorSetter<TEnabled, TElement>;
+}
+type FormOptional<TEnabled extends SignalForm, TElement extends SignalForm> = FormOptional$1<TEnabled, TElement>;
+declare function FormOptional<TEnabled extends SignalForm, TElement extends SignalForm>(enabled: IsEqualType<GetSignalFormParam<TEnabled, "output.schema">, boolean> extends true ? TEnabled : never, element: TElement, { input, initial, touched, validateOn, error }?: FormOptionalOptions<TEnabled, TElement>): FormOptional<TEnabled, TElement>;
+
+declare function isFormOptional(anything: unknown): anything is FormOptional$1<SignalForm, SignalForm>;
+
+type FormSwitchBranches<TKind extends SignalForm> = GetSignalFormParam<TKind, "output.schema"> extends string ? Record<GetSignalFormParam<TKind, "output.schema">, SignalForm> : never;
+
+interface FormSwitchConciseSchema<TActive, TBranch> {
+    readonly active: TActive;
+    readonly branch: TBranch;
+}
+
+interface FormSwitchVerboseSchema<TActive, TBranches> {
+    readonly active: TActive;
+    readonly branches: TBranches;
+}
+
+type GetFormSwitchBranchesParam<TBranches extends FormSwitchBranches<SignalForm>, TKey extends keyof SignalFormParams> = Compute<{
+    readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], TKey>;
+}>;
+
+type FormSwitchVerboseParam<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>, TKey extends keyof SignalFormParams> = Compute<FormSwitchVerboseSchema<GetSignalFormParam<TKind, TKey>, GetFormSwitchBranchesParam<TBranches, TKey>>>;
+
+type FormSwitchErrorVerbose<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitchVerboseParam<TKind, TBranches, "error.schema.verbose">;
+
+interface FormSwitchBranch<TKind, TValue> {
+    readonly kind: TKind;
+    readonly value: TValue;
+}
+
+type FormSwitchBranchUnion<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>, TKey extends keyof SignalFormParams> = {
+    [TBranch in GetSignalFormOutput<TKind>]: FormSwitchBranch<TBranch, GetSignalFormParam<TBranches[TBranch], TKey>>;
+}[GetSignalFormOutput<TKind>];
+
+type FormSwitchErrorSetter<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = Setter<null | Partial<FormSwitchConciseSchema<GetSignalFormParam<TKind, "error.setter">, Setter<null | FormSwitchBranchUnion<TKind, TBranches, "error.setter">, [
+    FormSwitchBranchUnion<TKind, TBranches, "error.schema.verbose">
+]>>> | Partial<FormSwitchVerboseSchema<GetSignalFormParam<TKind, "error.setter">, Setter<null | Partial<GetFormSwitchBranchesParam<TBranches, "error.setter">>, [
+    GetFormSwitchBranchesParam<TBranches, "error.schema.verbose">
+]>>>, [
+    FormSwitchErrorVerbose<TKind, TBranches>
+]>;
+
+type FormSwitchFlagVerbose<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitchVerboseParam<TKind, TBranches, "flag.schema.verbose">;
+
+type FormSwitchFlagSetter<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = Setter<boolean | Partial<FormSwitchConciseSchema<GetSignalFormParam<TKind, "flag.setter">, Setter<boolean | FormSwitchBranchUnion<TKind, TBranches, "flag.setter">, [
+    FormSwitchBranchUnion<TKind, TBranches, "flag.schema.verbose">
+]>>> | Partial<FormSwitchVerboseSchema<GetSignalFormParam<TKind, "flag.setter">, Setter<boolean | Partial<GetFormSwitchBranchesParam<TBranches, "flag.setter">>, [
+    GetFormSwitchBranchesParam<TBranches, "flag.schema.verbose">
+]>>>, [
+    FormSwitchFlagVerbose<TKind, TBranches>
+]>;
+
+type FormSwitchInput<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitchVerboseParam<TKind, TBranches, "input.schema">;
+
+type FormSwitchInputSetter<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = Setter<Partial<FormSwitchVerboseSchema<GetSignalFormParam<TKind, "input.setter">, Setter<Partial<GetFormSwitchBranchesParam<TBranches, "input.setter">>, [
+    GetFormSwitchBranchesParam<TBranches, "input.schema">,
+    GetFormSwitchBranchesParam<TBranches, "input.schema">
+]>>>, [
+    FormSwitchInput<TKind, TBranches>,
+    FormSwitchInput<TKind, TBranches>
+]>;
+
+type FormSwitchValidateOnVerbose<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitchVerboseParam<TKind, TBranches, "validateOn.schema.verbose">;
+
+type FormSwitchValidateOnSetter<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = Setter<ValidateStrategy | Partial<FormSwitchConciseSchema<GetSignalFormParam<TKind, "validateOn.setter">, Setter<ValidateStrategy | FormSwitchBranchUnion<TKind, TBranches, "validateOn.setter">, [
+    FormSwitchBranchUnion<TKind, TBranches, "validateOn.schema.verbose">
+]>>> | Partial<FormSwitchVerboseSchema<GetSignalFormParam<TKind, "validateOn.setter">, Setter<ValidateStrategy | Partial<GetFormSwitchBranchesParam<TBranches, "validateOn.setter">>, [
+    GetFormSwitchBranchesParam<TBranches, "validateOn.schema.verbose">
+]>>>, [
+    FormSwitchValidateOnVerbose<TKind, TBranches>
+]>;
+
+type FormSwitchActiveBranch<TBranches extends FormSwitchBranches<SignalForm>> = {
+    [TBranch in keyof TBranches]: FormSwitchBranch<TBranch, TBranches[TBranch]>;
+}[keyof TBranches];
+
+type FormSwitchConciseParam<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>, TKey extends keyof SignalFormParams, TConcise> = TConcise | FormSwitchConciseSchema<TConcise | GetSignalFormParam<TKind, TKey>, TConcise | FormSwitchBranchUnion<TKind, TBranches, TKey>>;
+
+type FormSwitchError<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitchConciseParam<TKind, TBranches, "error.schema", null>;
+
+type FormSwitchFlag<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitchConciseParam<TKind, TBranches, "flag.schema", boolean>;
+
+type FormSwitchOutput<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitchBranchUnion<TKind, TBranches, "output.schema">;
+
+type FormSwitchOutputVerbose<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitchVerboseParam<TKind, TBranches, "output.schema.verbose">;
+
+type FormSwitchValidateOn<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitchConciseParam<TKind, TBranches, "validateOn.schema", ValidateStrategy>;
+
+interface FormSwitchParams<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> extends SignalFormParams {
+    "input.schema": FormSwitchInput<TKind, TBranches>;
+    "input.setter": FormSwitchInputSetter<TKind, TBranches>;
+    "output.schema": FormSwitchOutput<TKind, TBranches>;
+    "output.schema.verbose": FormSwitchOutputVerbose<TKind, TBranches>;
+    "flag.setter": FormSwitchFlagSetter<TKind, TBranches>;
+    "flag.schema": FormSwitchFlag<TKind, TBranches>;
+    "flag.schema.verbose": FormSwitchFlagVerbose<TKind, TBranches>;
+    "validateOn.setter": FormSwitchValidateOnSetter<TKind, TBranches>;
+    "validateOn.schema": FormSwitchValidateOn<TKind, TBranches>;
+    "validateOn.schema.verbose": FormSwitchValidateOnVerbose<TKind, TBranches>;
+    "error.setter": FormSwitchErrorSetter<TKind, TBranches>;
+    "error.schema": FormSwitchError<TKind, TBranches>;
+    "error.schema.verbose": FormSwitchErrorVerbose<TKind, TBranches>;
+}
+
+type FormSwitchStateBranches<TBranches> = {
+    [TBranch in keyof TBranches]: SignalFormState<GetSignalFormParams<TBranches[TBranch]>>;
+};
+type ActiveSwitchStateBranch<TBranches> = FormSwitchBranch<keyof TBranches, FormSwitchStateBranches<TBranches>[keyof TBranches]>;
+declare class FormSwitchState<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> extends SignalFormState<FormSwitchParams<TKind, TBranches>> {
+    readonly _host: Lazy<FormSwitch$1<TKind, TBranches>>;
+    readonly _active: SignalFormState<GetSignalFormParams<TKind>>;
+    readonly _branches: FormSwitchStateBranches<TBranches>;
+    constructor(parent: null | SignalFormState, active: SignalFormState<GetSignalFormParams<TKind>>, branches: FormSwitchStateBranches<TBranches>);
+    _getActiveBranch(monitor: Monitor): undefined | ActiveSwitchStateBranch<TBranches>;
+    private _toConcise;
+    private _toVerbose;
+    _childOf(parent: null | SignalFormState): FormSwitchState<TKind, TBranches>;
+    readonly _initial: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "input.schema">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "input.schema">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "input.schema">; }[K]; };
+    }>;
+    _setInitial(monitor: Monitor, setter: FormSwitchInputSetter<TKind, TBranches>): void;
+    _replaceInitial(monitor: Monitor, state: undefined | FormSwitchState<TKind, TBranches>, isMounting: boolean): void;
+    readonly _input: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "input.schema">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "input.schema">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "input.schema">; }[K]; };
+    }>;
+    _setInput(monitor: Monitor, setter: FormSwitchInputSetter<TKind, TBranches>): void;
+    readonly _error: _owanturist_signal.ReadonlySignal<FormSwitchError<TKind, TBranches>>;
+    readonly _errorVerbose: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "error.schema.verbose">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "error.schema.verbose">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "error.schema.verbose">; }[K]; };
+    }>;
+    _setError(monitor: Monitor, setter: FormSwitchErrorSetter<TKind, TBranches>): void;
+    readonly _validateOn: _owanturist_signal.ReadonlySignal<FormSwitchValidateOn<TKind, TBranches>>;
+    readonly _validateOnVerbose: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "validateOn.schema.verbose">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "validateOn.schema.verbose">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "validateOn.schema.verbose">; }[K]; };
+    }>;
+    _setValidateOn(monitor: Monitor, setter: FormSwitchValidateOnSetter<TKind, TBranches>): void;
+    readonly _touched: _owanturist_signal.ReadonlySignal<FormSwitchFlag<TKind, TBranches>>;
+    readonly _touchedVerbose: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "flag.schema.verbose">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }[K]; };
+    }>;
+    _setTouched(monitor: Monitor, setter: FormSwitchFlagSetter<TKind, TBranches>): void;
+    readonly _output: _owanturist_signal.ReadonlySignal<FormSwitchOutput<TKind, TBranches> | null>;
+    readonly _outputVerbose: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "output.schema.verbose">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "output.schema.verbose">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "output.schema.verbose">; }[K]; };
+    }>;
+    readonly _valid: _owanturist_signal.ReadonlySignal<FormSwitchFlag<TKind, TBranches>>;
+    readonly _validVerbose: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "flag.schema.verbose">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }[K]; };
+    }>;
+    readonly _invalid: _owanturist_signal.ReadonlySignal<FormSwitchFlag<TKind, TBranches>>;
+    readonly _invalidVerbose: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "flag.schema.verbose">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }[K]; };
+    }>;
+    readonly _validated: _owanturist_signal.ReadonlySignal<FormSwitchFlag<TKind, TBranches>>;
+    readonly _validatedVerbose: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "flag.schema.verbose">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }[K]; };
+    }>;
+    _forceValidated(monitor: Monitor): void;
+    readonly _dirty: _owanturist_signal.ReadonlySignal<FormSwitchFlag<TKind, TBranches>>;
+    readonly _dirtyVerbose: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "flag.schema.verbose">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }[K]; };
+    }>;
+    readonly _dirtyOn: _owanturist_signal.ReadonlySignal<FormSwitchFlag<TKind, TBranches>>;
+    readonly _dirtyOnVerbose: _owanturist_signal.ReadonlySignal<{
+        readonly active: GetSignalFormParam<TKind, "flag.schema.verbose">;
+        readonly branches: { [K in keyof { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }]: { readonly [TBranch in keyof TBranches]: GetSignalFormParam<TBranches[TBranch], "flag.schema.verbose">; }[K]; };
+    }>;
+    _reset(monitor: Monitor, resetter: undefined | FormSwitchInputSetter<TKind, TBranches>): void;
+    _getChildren<TChildParams extends SignalFormParams>(monitor: Monitor): ReadonlyArray<SignalFormChild<TChildParams, FormSwitchParams<TKind, TBranches>>>;
+}
+
+declare class FormSwitch$1<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> extends SignalForm<FormSwitchParams<TKind, TBranches>> {
+    readonly _state: FormSwitchState<TKind, TBranches>;
+    static _getState: typeof SignalForm._getState;
+    readonly active: TKind;
+    readonly branches: Readonly<TBranches>;
+    constructor(_state: FormSwitchState<TKind, TBranches>);
+    getActiveBranch(monitor: Monitor): undefined | FormSwitchActiveBranch<TBranches>;
+}
+
+interface FormSwitchOptions<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> {
+    input?: FormSwitchInputSetter<TKind, TBranches>;
+    initial?: FormSwitchInputSetter<TKind, TBranches>;
+    touched?: FormSwitchFlagSetter<TKind, TBranches>;
+    validateOn?: FormSwitchValidateOnSetter<TKind, TBranches>;
+    error?: FormSwitchErrorSetter<TKind, TBranches>;
+}
+type FormSwitch<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>> = FormSwitch$1<TKind, TBranches>;
+declare function FormSwitch<TKind extends SignalForm, TBranches extends FormSwitchBranches<TKind>>(active: TKind, branches: IsEqualType<GetSignalFormParam<TKind, "output.schema">, keyof TBranches> extends true ? TBranches : never, { input, initial, touched, validateOn, error }?: FormSwitchOptions<TKind, TBranches>): FormSwitch<TKind, TBranches>;
+
+declare function isFormSwitch(anything: unknown): anything is FormSwitch$1<SignalForm, FormSwitchBranches<SignalForm>>;
+
+export { FormList, type FormListError, type FormListErrorSetter, type FormListErrorVerbose, type FormListFlag, type FormListFlagSetter, type FormListFlagVerbose, type FormListInput, type FormListInputSetter, type FormListOptions, type FormListOutput, type FormListOutputVerbose, type FormListParams, type FormListValidateOn, type FormListValidateOnSetter, type FormListValidateOnVerbose, type FormMeta, FormOptional, type FormOptionalError, type FormOptionalErrorSetter, type FormOptionalErrorVerbose, type FormOptionalFlag, type FormOptionalFlagSetter, type FormOptionalFlagVerbose, type FormOptionalInput, type FormOptionalInputSetter, type FormOptionalOptions, type FormOptionalOutput, type FormOptionalOutputVerbose, type FormOptionalParams, type FormOptionalSchema, type FormOptionalValidateOn, type FormOptionalValidateOnSetter, type FormOptionalValidateOnVerbose, FormShape, type FormShapeError, type FormShapeErrorSetter, type FormShapeErrorVerbose, type FormShapeFields, type FormShapeFlag, type FormShapeFlagSetter, type FormShapeFlagVerbose, type FormShapeInput, type FormShapeInputSetter, type FormShapeOptions, type FormShapeOutput, type FormShapeOutputVerbose, type FormShapeParams, type FormShapeValidateOn, type FormShapeValidateOnSetter, type FormShapeValidateOnVerbose, FormSwitch, type FormSwitchActiveBranch, type FormSwitchBranch, type FormSwitchBranches, type FormSwitchConciseSchema, type FormSwitchError, type FormSwitchErrorSetter, type FormSwitchErrorVerbose, type FormSwitchFlag, type FormSwitchFlagSetter, type FormSwitchFlagVerbose, type FormSwitchInput, type FormSwitchInputSetter, type FormSwitchOptions, type FormSwitchOutput, type FormSwitchOutputVerbose, type FormSwitchParams, type FormSwitchValidateOn, type FormSwitchValidateOnSetter, type FormSwitchValidateOnVerbose, type FormSwitchVerboseSchema, FormUnit, type FormUnitErrorSetter, type FormUnitFlagSetter, type FormUnitInputSetter, type FormUnitOptions, type FormUnitParams, type FormUnitSchemaOptions, type FormUnitTransformedOptions, type FormUnitTransformer, type FormUnitValidateOnSetter, type FormUnitValidatedOptions, type FormUnitValidator, type GetFormShapeParam, type GetFormSwitchBranchesParam, type GetSignalFormError, type GetSignalFormErrorSetter, type GetSignalFormErrorVerbose, type GetSignalFormFlag, type GetSignalFormFlagSetter, type GetSignalFormFlagVerbose, type GetSignalFormInput, type GetSignalFormInputSetter, type GetSignalFormOutput, type GetSignalFormOutputVerbose, type GetSignalFormParam, type GetSignalFormValidateOn, type GetSignalFormValidateOnSetter, type GetSignalFormValidateOnVerbose, type Result, SignalForm, type SignalFormParams, VALIDATE_ON_CHANGE, VALIDATE_ON_INIT, VALIDATE_ON_SUBMIT, VALIDATE_ON_TOUCH, type ValidateStrategy, type ZodLikeError, type ZodLikeIssue, type ZodLikeSafeParseResult, type ZodLikeSchema, isFormList, isFormOptional, isFormShape, isFormSwitch, isFormUnit, isSignalForm, zodLikeParse };