import { r as UnionVariants } from "./union-schema-B-Lsy588.mjs";
import { Validator } from "typebox/schema";
import { Static, TLiteral, TObject, TSchema, TUnion } from "typebox";

//#region src/form/form-field.model.d.ts
declare class FormFieldModel<T extends T.TSchema = T.TSchema> {
  readonly name: string;
  readonly schema: T;
  readonly config: FormFieldConfig<T>;
  readonly validator: Validator<T>;
  value: T.Static<T> | undefined;
  touched: boolean;
  /**
   * An error set by hand rather than derived from the schema — typically a server response, or a rule
   * the schema can't express, applied from inside `handleSubmit`. Use `setError`.
   *
   * Distinct from `errorMessage`, which is what to *display*: this one when set, the schema's otherwise.
   */
  error: string | undefined;
  get valid(): boolean;
  get errorMessage(): string;
  constructor(config: FormFieldConfig<T>);
  setValue(value?: T.Static<T>): void;
  /** Set (or with `undefined`, clear) a manual error. Cleared automatically by an edit, a reset, or the next submit. */
  setError(error: string | undefined): void;
  private convertValue;
  setTouched(touched: boolean): void;
  reset(): void;
  props(): any;
  toJSON(): T.Static<T> | undefined;
}
//#endregion
//#region src/form/form.types.d.ts
type FormSchema = TObject | TUnion;
interface FormConfig<T extends FormSchema = TObject> {
  handleSubmit: (data: Static<T>) => Promise<unknown>;
  /**
   * Called when `handleSubmit` throws — for a toast, a report to your error tracker, or mapping an API
   * error onto fields with `form.fields.x.setError(...)`.
   *
   * `submitError` is already set by the time this runs, so a handler that wants to own presentation
   * entirely can clear it with `form.setSubmitError(undefined)` and render nothing from the form.
   *
   * Providing this **replaces the default `console.error`**. Without it, the rejection is consumed by
   * the form's own `catch` and a thrown error would otherwise be completely invisible — so if you take
   * over, logging unexpected failures becomes yours too.
   */
  handleError?: (error: unknown, form: FormModel<T>) => void;
  initialValues?: FormInitialValues<T>;
}
interface FormFieldConfig<T extends TSchema = TSchema> {
  name: string;
  schema: T;
  initialValue?: Static<T>;
}
type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
/** Keys present on the variant `O` (a single union member). */
type VariantKeys<O> = O extends TObject ? keyof O["properties"] : never;
/** Keys present on *every* variant — the shared base + discriminator. */
type SharedKeys<O> = UnionToIntersection<O extends TObject ? {
  k: keyof O["properties"];
} : never> extends {
  k: infer K extends PropertyKey;
} ? K : never;
/** The schema of key `K` across the variants that declare it (unioned when they differ). */
type VariantSchema<O, K extends PropertyKey> = O extends TObject ? K extends keyof O["properties"] ? O["properties"][K] : never : never;
/** The static value type of key `K` across the variants that declare it. */
type VariantValue<O, K extends PropertyKey> = O extends TObject ? K extends keyof O["properties"] ? Static<O["properties"][K]> : never : never;
type FormFields<T extends FormSchema = TObject> = T extends TUnion<infer V> ? { [K in SharedKeys<UnionVariants<V[number]>>]: FormFieldModel<VariantSchema<UnionVariants<V[number]>, K>> } : T extends TObject ? { [K in keyof T["properties"]]: FormFieldModel<T["properties"][K]> } : never;
type RawFormFields<T extends FormSchema = TObject> = T extends TUnion<infer V> ? { [K in VariantKeys<UnionVariants<V[number]>>]: FormFieldModel<VariantSchema<UnionVariants<V[number]>, K>> } : T extends TObject ? { [K in keyof T["properties"]]: FormFieldModel<T["properties"][K]> } : never;
type FormInitialValues<T extends FormSchema> = T extends TUnion<infer V> ? { [K in VariantKeys<UnionVariants<V[number]>>]?: VariantValue<UnionVariants<V[number]>, K> } : T extends TObject ? Partial<Static<T>> : never;
/** Keys that are typed as a literal in at least one variant — valid discriminators. */
type DiscriminatorKeys<T extends TUnion> = T extends TUnion<infer V> ? LiteralKeys<UnionVariants<V[number]>> : never;
type LiteralKeys<O> = O extends TObject ? { [K in keyof O["properties"]]: O["properties"][K] extends TLiteral ? K : never }[keyof O["properties"]] : never;
/** The literal values a given discriminator key can take across all variants. */
type DiscriminatorValue<T extends TUnion, D extends PropertyKey> = T extends TUnion<infer V> ? LiteralValue<UnionVariants<V[number]>, D> : never;
type LiteralValue<O, D extends PropertyKey> = O extends TObject ? D extends keyof O["properties"] ? O["properties"][D] extends TLiteral<infer L> ? L : never : never : never;
/** The variant object whose discriminator `D` equals the literal `V`. */
type MatchVariant<T extends TUnion, D extends PropertyKey, V> = T extends TUnion<infer Vars> ? Distribute<UnionVariants<Vars[number]>, D, V> : never;
type Distribute<O, D extends PropertyKey, V> = O extends TObject ? D extends keyof O["properties"] ? O["properties"][D] extends TLiteral<infer L> ? V extends L ? O : never : never : never : never;
//#endregion
//#region src/form/form.model.d.ts
declare class FormModel<T extends FormSchema = TObject> {
  /** Shared fields only (for unions); every field for a plain object schema. */
  readonly fields: FormFields<T>;
  /** Every field across all variants — escape hatch for reaching variant fields. */
  readonly rawFields: RawFormFields<T>;
  readonly config: FormConfig<T>;
  readonly schema: T;
  readonly validator: Validator<T>;
  submitting: boolean;
  submitted: boolean;
  /**
   * Whatever `handleSubmit` last threw. `unknown` rather than `any`: it may be an `Error`, an API
   * error object, or a string, and narrowing at the render site is the only safe way to read it.
   */
  submitError: unknown;
  constructor(schema: T, config: FormConfig<T>);
  get valid(): boolean;
  props(): any;
  setSubmitError(error: unknown): void;
  protected setSubmitting(submitting: boolean): void;
  protected setSubmitted(submitted: boolean): void;
  reset(): void;
  validate(): boolean;
  toJSON(): Partial<Static<T>>;
}
//#endregion
//#region src/form/components/form.d.ts
interface MobxFormProps extends Omit<React.HTMLProps<HTMLFormElement>, "form" | "action" | "method"> {
  form: FormModel<any>;
}
declare const MobxForm: import("react").ForwardRefExoticComponent<Omit<MobxFormProps, "ref"> & import("react").RefAttributes<unknown>>;
//#endregion
//#region src/form/components/form-when.d.ts
interface FormWhenProps<T extends TUnion, D extends DiscriminatorKeys<T>, V extends string> {
  form: FormModel<T>;
  /** The discriminator field name. */
  field: D;
  /** Render the children only while the discriminator field equals this value. */
  value: V & DiscriminatorValue<T, D>;
  /** Receives the matching variant's fields. The form itself is already in scope. */
  children: (fields: FormFields<MatchVariant<T, D, V>>) => React.ReactNode;
}
/**
 * Renders its children only when the form's discriminator field currently holds
 * `value`, passing the fields narrowed to that variant. Stack one per variant to
 * lay out a discriminated-union form without manual conditionals or casts.
 */
declare function FormWhen<T extends TUnion, D extends DiscriminatorKeys<T>, V extends string>({
  form,
  field,
  value,
  children
}: FormWhenProps<T, D, V>): import("react/jsx-runtime").JSX.Element;
//#endregion
//#region src/form/form.context.d.ts
declare const formContext: import("react").Context<FormModel<import("typebox").TObject<import("typebox").TProperties>> | undefined>;
declare const useFormContext: () => FormModel<import("typebox").TObject<import("typebox").TProperties>>;
declare const FormProvider: import("react").Provider<FormModel<import("typebox").TObject<import("typebox").TProperties>> | undefined>;
declare const useFormContextIfAvailable: () => FormModel<import("typebox").TObject<import("typebox").TProperties>> | undefined;
//#endregion
//#region src/form/use-form.d.ts
declare const useForm: <T extends FormSchema = TObject>(schema: T, config: FormConfig<T>) => FormModel<T>;
//#endregion
export { DiscriminatorKeys, DiscriminatorValue, FormConfig, FormFieldConfig, FormFieldModel, FormFields, FormModel, FormProvider, FormSchema, FormWhen, FormWhenProps, MatchVariant, MobxForm, MobxFormProps, RawFormFields, formContext, useForm, useFormContext, useFormContextIfAvailable };
//# sourceMappingURL=form.d.mts.map