import { A as GetKeys, B as Value, C as Selector, F as PathAsString, G as MaybePromise, H as WildcardPathAsString, I as SettablePath, K as Constrain, N as Path$1, T as Update, U as WildcardValue, W as Object_, b as Duration, j as Join, r as Store } from "../store-21GsOOLS.cjs";
import { a as useScope, c as UseCacheValue, d as useStore, i as ScopeProvider, l as useCache, n as scopeMethods, o as cacheMethods, r as ScopeProps, s as UseCacheArray, t as storeMethods, u as UseStoreOptions } from "../storeMethods-BjuI0joo.cjs";
import { Draft } from "mutative";
import { Component, ComponentPropsWithoutRef, Context, FormEvent, FunctionComponent, HTMLProps, ReactNode } from "react";

//#region src/react/form/customInput.d.ts
interface CustomInputProps extends React.HTMLAttributes<HTMLDivElement> {
  name: string;
  children?: ReactNode;
}
declare function CustomInput({
  name,
  children,
  ...props
}: CustomInputProps): React.JSX.Element;
//#endregion
//#region src/react/form/formField.d.ts
interface FormFieldComponentProps<TValue, TPath$1> {
  name: TPath$1;
  value: TValue;
  onChange: (event: {
    target: {
      value: TValue;
    };
  } | TValue | undefined, ...args: any[]) => void;
  onBlur: (...args: any[]) => void;
  "data-invalid"?: boolean;
}
type FormFieldInfos<TDraft, TOriginal, TPath$1 extends string> = Field<TDraft, TOriginal, TPath$1> & {
  hasTriggeredValidations: boolean;
};
type NativeInputType = "input" | "select" | "textarea";
type PartialComponentType<P> = (new (props: P, context?: any) => Component<P, any>) | ((props: P, context?: any) => ReactNode);
type FormFieldComponent = NativeInputType | PartialComponentType<any>;
interface FormFieldProps<TPath$1, TDraft> extends FieldOptions {
  name: TPath$1 extends PathAsString<TDraft> ? TPath$1 : PathAsString<TDraft>;
  commitOnBlur?: boolean;
  commitDebounce?: Duration;
}
interface FormFieldPropsWithRender<TDraft, TOriginal, TPath$1 extends string> extends FormFieldProps<TPath$1, TDraft> {
  render: NoInfer<(props: FormFieldComponentProps<Value<TDraft, TPath$1>, TPath$1>, info: FormFieldInfos<TDraft, TOriginal, TPath$1>, form: FormContext<TDraft, TOriginal>) => ReactNode>;
  children?: undefined;
}
interface FormFieldPropsWithChildren<TDraft, TOriginal, TPath$1 extends string> extends FormFieldProps<TPath$1, TDraft> {
  render?: undefined;
  children: NoInfer<(props: FormFieldComponentProps<Value<TDraft, TPath$1>, TPath$1>, info: FormFieldInfos<TDraft, TOriginal, TPath$1>, form: FormContext<TDraft, TOriginal>) => ReactNode>;
}
//#endregion
//#region src/react/form/legacyFormField.d.ts
type FieldValue<T$1 extends FormFieldComponent> = ComponentPropsWithoutRef<T$1>["value"];
type FieldChangeValue<T$1 extends FormFieldComponent> = ComponentPropsWithoutRef<T$1> extends {
  onChange?: (update: infer U) => void;
} ? U extends {
  target: {
    value: infer V;
  };
} ? V : U : never;
type MakeOptional<T$1, Keys extends string> = Omit<T$1, Keys> & Partial<Pick<T$1, Keys & keyof T$1>>;
type Serialize<TDraft, TOriginal, TPath$1, TComponent extends FormFieldComponent> = (value: Value<TDraft, TPath$1>, formState: FormInstance<TDraft, TOriginal>) => FieldValue<TComponent>;
type Deserialize<TDraft, TOriginal, TPath$1, TComponent extends FormFieldComponent> = (value: FieldChangeValue<TComponent>, formState: FormInstance<TDraft, TOriginal>) => Value<TDraft, TPath$1>;
type FormFieldPropsWithComponent<TDraft, TOriginal, TPath$1 extends string, TComponent extends FormFieldComponent> = FormFieldProps<TPath$1, TDraft> & {
  component: TComponent;
  render?: undefined;
} & NoInfer<{
  inputFilter?: (value: FieldChangeValue<TComponent>) => boolean;
} & MakeOptional<Omit<ComponentPropsWithoutRef<TComponent>, "id" | "name" | "value" | "defaultValue">, "onChange" | "onBlur"> & (Value<TDraft, TPath$1> extends Exclude<FieldValue<TComponent>, undefined> ? {
  defaultValue?: FieldValue<TComponent>;
  serialize?: Serialize<TDraft, TOriginal, TPath$1, TComponent>;
} : Value<TDraft, TPath$1> extends FieldValue<TComponent> ? {
  defaultValue: FieldValue<TComponent>;
  serialize?: Serialize<TDraft, TOriginal, TPath$1, TComponent>;
} | {
  defaultValue?: FieldValue<TComponent>;
  serialize: Serialize<TDraft, TOriginal, TPath$1, TComponent>;
} : {
  serialize: Serialize<TDraft, TOriginal, TPath$1, TComponent>;
}) & (FieldChangeValue<TComponent> extends Value<TDraft, TPath$1> ? {
  deserialize?: Deserialize<TDraft, TOriginal, TPath$1, TComponent>;
} : {
  deserialize: Deserialize<TDraft, TOriginal, TPath$1, TComponent>;
})>;
//#endregion
//#region src/react/form/formForEach.d.ts
type ElementName<TDraft, TPath$1 extends string> = keyof { [Path in TPath$1 as Join<Path, GetKeys<NonNullable<Value<TDraft, Path>>> & (string | number)>]: 1 };
type ItemValue<T$1> = T$1 extends readonly (infer U)[] ? U : T$1[keyof T$1];
interface FormForEachProps<TDraft, TPath$1 extends string> {
  name: TPath$1 extends PathAsString<TDraft> ? TPath$1 : PathAsString<TDraft>;
  renderElement?: (props: {
    name: ElementName<TDraft, TPath$1>;
    key: `${GetKeys<NonNullable<Value<TDraft, TPath$1>>> & (string | number)}`;
    index: number;
    remove: () => void;
    count: number;
  }) => ReactNode;
  renderAdditionalElement?: NonNullable<Value<TDraft, TPath$1>> extends readonly any[] ? boolean : never;
  filter?: (item: ItemValue<NonNullable<Value<TDraft, TPath$1>>>, key: GetKeys<NonNullable<Value<TDraft, TPath$1>>>, parent: NonNullable<Value<TDraft, TPath$1>>) => boolean;
  children?: (props: {
    setValue: (value: Value<TDraft, TPath$1> | ((value: Value<TDraft, TPath$1>) => Value<TDraft, TPath$1>)) => void;
  } & FieldHelperMethods<TDraft, TPath$1>) => ReactNode;
}
//#endregion
//#region src/react/form/formOnOriginalChange.d.ts
interface OnOriginalChangeHandler<TDraft, TOriginal> {
  (oldOriginal: TOriginal | undefined, newOriginal: TOriginal | undefined, draft: TDraft, form: FormContext<TDraft, TOriginal>): TDraft | void;
}
type OnOriginalChangeBuiltin = "default" | "merge" | "overwrite";
type OnOriginalChange<TDraft, TOriginal> = OnOriginalChangeHandler<TDraft, TOriginal> | OnOriginalChangeBuiltin;
//#endregion
//#region src/react/form/useFormAutosave.d.ts
interface FormAutosaveOptions<TDraft, TOriginal> {
  enabled?: boolean;
  validateBeforeSave?: boolean;
  save?: (draft: TDraft, prev: TDraft, form: FormContext<TDraft, TOriginal>) => MaybePromise<void>;
  debounce?: Duration;
  resetAfterSave?: boolean;
  equals?: (a: any, b: any) => boolean;
}
//#endregion
//#region src/react/form/form.d.ts
interface Transform<TDraft, TOriginal> {
  (value: Draft<TDraft>, context: TransformContext<TDraft, TOriginal>): void | TDraft;
}
interface TransformContext<TDraft, TOriginal> extends FormContext<TDraft, TOriginal> {
  previousValue: TDraft;
}
interface FormOptions<TDraft, TOriginal> {
  id?: string;
  defaultValue: TDraft;
  validations?: Validations<TDraft, TOriginal>;
  initiallyTriggerValidations?: boolean;
  localizeError?: (error: string, field: string) => string | undefined;
  autoSave?: FormAutosaveOptions<TDraft, TOriginal>;
  transform?: Transform<TDraft, TOriginal>;
  validatedClass?: string;
  original?: TOriginal;
  onSubmit?: (event: FormEvent<HTMLFormElement>, form: FormInstance<TDraft, TOriginal>) => void;
  reportValidity?: boolean | "browser" | "scrollTo";
  transformFieldProps?: <TPath$1 extends string>(props: FormFieldComponentProps<Value<TDraft, TPath$1>, TPath$1>, info: FormFieldInfos<TDraft, TOriginal, TPath$1>, form: FormContext<TDraft, TOriginal>) => FormFieldComponentProps<Value<TDraft, TPath$1>, TPath$1>;
  onOriginalChange?: OnOriginalChange<TDraft, TOriginal>;
}
type Validations<TDraft, TOriginal> = ((context: {
  draft: TDraft;
  original: TOriginal | undefined;
}) => Iterable<{
  name: string;
  error: string;
}>) | ({ [TPath in WildcardPathAsString<TDraft>]?: Record<string, Validation<TDraft, TOriginal, TPath>> } & Record<string, Record<string, Validation<TDraft, TOriginal, any>>>);
type Validation<TDraft, TOriginal, TPath$1> = (value: WildcardValue<TDraft, TPath$1>, context: {
  draft: TDraft;
  original: TOriginal;
  field: PathAsString<TDraft> | "";
}) => boolean;
type Field<TDraft, TOriginal, TPath$1 extends string> = {
  originalValue: Value<TOriginal, TPath$1> | undefined;
  value: Value<TDraft, TPath$1>;
  setValue: (value: Update<Value<TDraft, TPath$1>>) => void;
  removeValue: () => void;
  hasChange: boolean;
  errors: string[];
} & (Value<TDraft, TPath$1> extends Object_ ? FieldHelperMethods<TDraft, TPath$1> : {});
type FieldHelperMethods<TDraft, TPath$1 extends string> = {
  names: ElementName<TDraft, TPath$1>[];
  add: NonNullable<Value<TDraft, TPath$1>> extends readonly (infer T)[] ? (element: T) => void : NonNullable<Value<TDraft, TPath$1>> extends Record<infer K, infer V> ? (key: K, value: V) => void : never;
  remove: NonNullable<Value<TDraft, TPath$1>> extends readonly any[] ? (index: number) => void : (key: string) => void;
};
interface FormState<TDraft> {
  draft: TDraft | undefined;
  hasTriggeredValidations: boolean;
  saveInProgress: boolean;
}
interface FormDerivedState<TDraft> {
  draft: TDraft;
  hasTriggeredValidations: boolean;
  saveInProgress: boolean;
  hasChanges: boolean;
  errors: Map<string, string[]>;
  isValid: boolean;
}
interface FormContext<TDraft, TOriginal> {
  formState: Store<FormState<TDraft>>;
  options: FormOptions<TDraft, TOriginal>;
  original: TOriginal | undefined;
  getField: <TPath$1 extends string>(name: TPath$1 extends PathAsString<TDraft> ? TPath$1 : PathAsString<TDraft>, options?: FieldOptions) => Field<TDraft, TOriginal, TPath$1>;
  getDraft: () => TDraft;
  hasTriggeredValidations: () => boolean;
  saveInProgress: () => boolean;
  flushAutosave: () => Promise<void>;
  cancelAutosave: () => void;
  hasChanges: () => boolean;
  getErrors: () => Map<string, string[]>;
  isValid: () => boolean;
  validate: (options?: ValidateOptions) => boolean;
  reset: () => void;
}
interface FieldOptions {
  includeNestedErrors?: boolean;
}
interface ValidateOptions {
  reportValidity?: boolean | "browser" | "scrollTo";
  button?: HTMLButtonElement;
}
interface FormInstance<TDraft, TOriginal> extends FormDerivedState<TDraft>, Pick<FormContext<TDraft, TOriginal>, "options" | "original" | "getField" | "validate" | "reset"> {}
declare class Form<TDraft, TOriginal extends TDraft = TDraft> {
  readonly options: FormOptions<TDraft, TOriginal>;
  context: Context<FormContext<TDraft, TOriginal> | null>;
  constructor(options: FormOptions<TDraft, TOriginal>);
  useForm(): FormContext<TDraft, TOriginal>;
  useFormState<S>(selector: (state: FormInstance<TDraft, TOriginal>) => S, useStoreOptions?: UseStoreOptions<S>): S;
  useField<TPath$1 extends string>(name: TPath$1 extends PathAsString<TDraft> ? TPath$1 : PathAsString<TDraft>, {
    includeNestedErrors,
    ...useStoreOptions
  }?: FieldOptions & UseStoreOptions<unknown>): Field<TDraft, TOriginal, TPath$1>;
  useFieldProps<TPath$1 extends string>(name: TPath$1 extends PathAsString<TDraft> ? TPath$1 : PathAsString<TDraft>, options?: Omit<FormFieldProps<TPath$1, TDraft>, "name">): FormFieldComponentProps<Value<TDraft, TPath$1>, TPath$1>;
  Form({
    defaultValue,
    validations,
    initiallyTriggerValidations,
    localizeError,
    autoSave,
    transform,
    validatedClass,
    original,
    onSubmit,
    reportValidity,
    transformFieldProps,
    onOriginalChange,
    ...formProps
  }: Partial<FormOptions<TDraft, TOriginal>> & Omit<HTMLProps<HTMLFormElement>, "defaultValue" | "autoSave" | "onSubmit">): React.JSX.Element;
  FormState<S>({
    selector,
    children
  }: {
    selector: (form: FormInstance<TDraft, TOriginal>) => S;
    children: (selectedState: S) => ReactNode;
  }): React.JSX.Element;
  Field<const TPath$1 extends string>(props: FormFieldPropsWithRender<TDraft, TOriginal, TPath$1>): React.JSX.Element;
  Field<const TPath$1 extends string>(props: FormFieldPropsWithChildren<TDraft, TOriginal, TPath$1>): React.JSX.Element;
  /** @deprecated */
  Field<const TPath$1 extends string, const TComponent extends FormFieldComponent = "input">(props: FormFieldPropsWithComponent<TDraft, TOriginal, TPath$1, TComponent>): React.JSX.Element;
  ForEach<const TPath$1 extends string>(props: FormForEachProps<TDraft, TPath$1>): React.JSX.Element;
  withForm<TProps extends Record<string, unknown>>(Component: React.ComponentType<TProps>, formProps?: Parameters<this["Form"]>[0]): FunctionComponent<TProps>;
}
declare function createForm<TDraft, TOriginal extends TDraft = TDraft>(options: FormOptions<TDraft, TOriginal>): Form<TDraft, TOriginal>;
//#endregion
//#region src/react/form/closestFormContext.d.ts
declare function useClosestForm<TDraft, TOriginal extends TDraft = TDraft>(): Form<TDraft, TOriginal> | null;
//#endregion
//#region src/react/loadingBoundary.d.ts
interface LoadingBoundaryEntry {
  label?: ReactNode;
}
interface LoadingBoundaryProps {
  /**
  * Fallback node to render when there are loading components within the boundary.
  */
  fallback?: ReactNode | ((entries: LoadingBoundaryEntry[]) => ReactNode);
  /**
  * Child node to render when there are no loading components within the boundary.
  */
  children?: ReactNode;
  /**
  * Add a loading state from outside the boundary. Useful for when you want to
  * show a loading state for a component that is not a child of the boundary.
  */
  isLoading?: boolean;
}
declare function LoadingBoundary({
  fallback,
  children,
  isLoading: isLoadingExternal
}: LoadingBoundaryProps): React.JSX.Element;
declare function useLoadingBoundary(isLoading: boolean | undefined, label?: ReactNode): void;
//#endregion
//#region src/react/url/urlOptions.d.ts
interface UrlOptions<T$1> {
  key: string;
  type?: "search" | "hash";
  serialize?: (value: T$1) => string;
  deserialize?: (value: string) => T$1;
  defaultValue: T$1;
  writeDefaultValue?: boolean;
  onCommit?: (value: T$1) => void;
  persist?: {
    id: string;
  } | null;
  path?: string | RegExp | (string | RegExp)[] | null;
}
interface UrlOptionsWithoutDefaults<T$1> extends Omit<UrlOptions<T$1 | undefined>, "defaultValue"> {
  defaultValue?: T$1 | undefined;
}
declare function createUrlOptions<T$1>(options: UrlOptions<T$1>): Required<UrlOptions<T$1>>;
declare function createUrlOptions<T$1>(options: UrlOptionsWithoutDefaults<T$1>): Required<UrlOptions<T$1 | undefined>>;
//#endregion
//#region src/react/url/urlParamStore.d.ts
declare const urlStore: Store<string>;
declare class UrlParamStore<T$1> extends Store<T$1> {
  readonly urlOptions: Required<UrlOptions<T$1>>;
  readonly storageKey: string | null;
  private lastHref?;
  private lastStorageValue?;
  private lastValue?;
  constructor(urlOptions: Required<UrlOptions<T$1>>);
  private watch;
  private getUrlValue;
  private getStorageValue;
  private isPathActive;
  private calc;
  private updateUrl;
  private updateStorage;
  set(update: Update<T$1>): void;
  set<const P>(path: Constrain<P, Path$1<T$1>>, update: Update<Value<T$1, P>>): void;
  parse(path: string): T$1;
}
declare function createUrlParam<T$1>(options: UrlOptions<T$1>): UrlParamStore<T$1>;
declare function createUrlParam<T$1>(options: UrlOptionsWithoutDefaults<T$1>): UrlParamStore<T$1 | undefined>;
//#endregion
//#region src/react/useDecoupledState.d.ts
interface UseDecoupledStateOptions<T$1> {
  debounce?: Duration;
  throttle?: Duration;
  onCommit?: (value: T$1) => void;
}
declare function useDecoupledState<T$1>(value: T$1, onChange: (value: T$1) => MaybePromise<void>, options?: UseDecoupledStateOptions<T$1>): [state: T$1, setState: (value: T$1) => void];
//#endregion
//#region src/react/useProp.d.ts
declare function useProp<T$1, S>(store: Store<T$1>, selector: Selector<T$1, S>, updater: (value: S) => Update<T$1>, options?: UseStoreOptions<S>): [value: S, setValue: Store<S>["set"]];
declare function useProp<T$1, const P>(store: Store<T$1>, selector: Constrain<P, SettablePath<T$1>>, options?: UseStoreOptions<Value<T$1, P>>): [value: Value<T$1, P>, setValue: Store<Value<T$1, P>>["set"]];
declare function useProp<T$1>(store: Store<T$1>, options?: UseStoreOptions<T$1>): [value: T$1, setValue: Store<T$1>["set"]];
//#endregion
export { CustomInput, CustomInputProps, Field, Form, FormContext, FormDerivedState, FormFieldComponent, FormFieldComponentProps, FormFieldInfos, FormFieldProps, FormFieldPropsWithChildren, FormFieldPropsWithRender, FormInstance, FormOptions, FormState, LoadingBoundary, type LoadingBoundaryEntry, type LoadingBoundaryProps, type ScopeProps, ScopeProvider, Transform, type UrlOptions, type UrlOptionsWithoutDefaults, type UrlParamStore, type UseCacheArray, type UseCacheValue, type UseDecoupledStateOptions, type UseStoreOptions, Validation, Validations, cacheMethods, createForm, createUrlOptions, createUrlParam, scopeMethods, storeMethods, urlStore, useCache, useClosestForm, useDecoupledState, useLoadingBoundary, useProp, useScope, useStore };
//# sourceMappingURL=index.d.cts.map