@strictly/react-form 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,345 @@
+import { Maybe, ElementOfArray, StringKeyOf as StringKeyOf$1, PrintableOf } from '@strictly/base';
+import { Type, ValueTypeOf, ReadonlyTypeDefOf, FlattenedTypeDefsOf, ListTypeDef, FlattenedValueTypesOf, MobxValueTypeOf, Accessor, UnionTypeDef, ValueTypesOfDiscriminatedUnion, LiteralTypeDef } from '@strictly/define';
+import { ValueOf, SimplifyDeep, ReadonlyDeep, StringKeyOf } from 'type-fest';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { CheckboxProps, PillProps, RadioProps, RadioGroupProps, TextInputProps, SelectProps } from '@mantine/core';
+import { ComponentType, ComponentProps, ForwardRefExoticComponent, PropsWithoutRef, DependencyList } from 'react';
+
+declare enum FieldConversionResult {
+    Success = 0,
+    Failure = 1
+}
+type FieldConversion<V, E> = {
+    type: FieldConversionResult.Success;
+    value: V;
+} | {
+    type: FieldConversionResult.Failure;
+    error: E;
+    value: Maybe<V>;
+};
+type FieldConverter<From, To, E, ValuePath extends string, Context> = {
+    (from: From, valuePath: ValuePath, context: Context): FieldConversion<To, E>;
+};
+type SafeFieldConverter<From, To, ValuePath extends string, Context> = {
+    (from: From, valuePath: ValuePath, context: Context): To;
+};
+type TwoWayFieldConverter<From, To, E, ValuePath extends string, Context> = {
+    convert: SafeFieldConverter<From, To, ValuePath, Context>;
+    revert: FieldConverter<To, From, E, ValuePath, Context>;
+};
+type FieldValueFactory<V, ValuePath extends string, Context> = {
+    (valuePath: ValuePath, context: Context): V;
+};
+type TwoWayFieldConverterWithValueFactory<From, To, E, ValuePath extends string, Context> = TwoWayFieldConverter<From, To, E, ValuePath, Context> & {
+    readonly create: FieldValueFactory<From, ValuePath, Context>;
+};
+
+type FieldValidator<V, E, ValuePath extends string, Context> = {
+    (value: V, valuePath: ValuePath, context: Context): E | null;
+};
+
+declare class FieldAdapterBuilder<From, To, E, ValuePath extends string, Context> {
+    readonly convert: SafeFieldConverter<From, To, ValuePath, Context>;
+    readonly create: FieldValueFactory<From, ValuePath, Context>;
+    readonly revert?: FieldConverter<To, From, E, ValuePath, Context> | undefined;
+    constructor(convert: SafeFieldConverter<From, To, ValuePath, Context>, create: FieldValueFactory<From, ValuePath, Context>, revert?: FieldConverter<To, From, E, ValuePath, Context> | undefined);
+    validateFrom<E2>(...validators: readonly FieldValidator<From, E2, ValuePath, Context>[]): FieldAdapterBuilder<From, To, E | E2, ValuePath, Context>;
+    validateTo<E2>(...validators: readonly FieldValidator<To, E2, ValuePath, Context>[]): FieldAdapterBuilder<From, To, E | E2, ValuePath, Context>;
+    chain<To2, E2 = E>(converter: SafeFieldConverter<To, To2, ValuePath, Context>, reverter?: FieldConverter<To2, To, E2, ValuePath, Context>): FieldAdapterBuilder<From, To2, E | E2, ValuePath, Context>;
+    withReverter(reverter: FieldConverter<To, From, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+    withIdentity(isFrom: (from: To | From) => from is From): FieldAdapterBuilder<From, To | From, E, ValuePath, Context>;
+}
+declare function adapter<From, To, ValuePath extends string, Context>(converter: SafeFieldConverter<From, To, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>): FieldAdapterBuilder<From, To, never, ValuePath, Context>;
+declare function adapter<From, To, E, ValuePath extends string, Context>(converter: SafeFieldConverter<From, To, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>, reverter: FieldConverter<To, From, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+declare function adapterFromTwoWayConverter<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+declare function adapterFromTwoWayConverter<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverterWithValueFactory<From, To, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+declare function adapterFromPrototype<From, To, ValuePath extends string, Context>(converter: SafeFieldConverter<From, To, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, never, ValuePath, Context>;
+declare function adapterFromPrototype<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+declare function identityAdapter<V, ValuePath extends string, Context>(prototype: V): FieldAdapterBuilder<V, V, never, ValuePath, Context>;
+declare function listAdapter<E, K extends string, ValuePath extends string, Context>(): FieldAdapterBuilder<readonly E[], readonly K[], never, ValuePath, Context>;
+
+type FieldAdapter<From = any, To = any, E = any, ValuePath extends string = any, Context = any> = {
+    readonly convert: SafeFieldConverter<From, To, ValuePath, Context>;
+    readonly create: FieldValueFactory<From, ValuePath, Context>;
+    readonly revert?: FieldConverter<To, From, E, ValuePath, Context>;
+};
+type ToTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _F, infer To> ? To : never;
+type ErrorTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _From, infer _To, infer E> ? NonNullable<E> : never;
+
+type Field<V = any, E = any> = {
+    readonly value: V;
+    readonly error?: E | undefined;
+    readonly disabled: boolean;
+    readonly required: boolean;
+};
+type Fields = Readonly<Record<string, Field>>;
+
+type FlattenedAdaptersOfFields<ValuePathsToTypePaths extends Readonly<Record<string, string>>, FlattenedTypeDefs extends Partial<Readonly<Record<ValueOf<ValuePathsToTypePaths>, Type>>>, FormFields extends Partial<Readonly<Record<keyof ValuePathsToTypePaths, Field>>>> = SimplifyDeep<{
+    readonly [K in keyof ValuePathsToTypePaths as FormFields[K] extends Field ? ValuePathsToTypePaths[K] : never]: AdapterOfField<NonNullable<FormFields[K]>, FlattenedTypeDefs[ValuePathsToTypePaths[K]], K>;
+}>;
+type AdapterOfField<F extends Field, T extends Type | undefined, ValuePath extends string | number | symbol> = ValuePath extends string ? F extends Field<infer V, infer E> ? undefined extends T ? FieldAdapter<V, V, E, ValuePath> : FieldAdapter<ValueTypeOf<ReadonlyTypeDefOf<NonNullable<T>>>, V, E, ValuePath> : never : never;
+
+type FlattenedListTypeDefsOf<T extends Type> = FlattenedListTypeDefsOfFlattened<SimplifyDeep<FlattenedTypeDefsOf<T, null>>>;
+type FlattenedListTypeDefsOfFlattened<T extends Readonly<Record<string, Type>>> = {
+    [K in keyof T as T[K]['definition'] extends ListTypeDef ? K : never]: T[K];
+};
+
+type FlattenedConvertedFieldsOf<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    readonly [K in keyof ValuePathsToAdapters]: Field<ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>, ErrorTypeOfFieldAdapter<ValuePathsToAdapters[K]>>;
+};
+type FlattenedTypePathsToAdaptersOf<FlattenedValues extends Readonly<Record<string, any>>, Context> = {
+    readonly [K in keyof FlattenedValues]?: FieldAdapter<ReadonlyDeep<FlattenedValues[K]>, any, any, any, Context>;
+};
+type FieldOverride<V = any> = {
+    value: V;
+};
+type FlattenedFieldOverrides<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    -readonly [K in keyof ValuePathsToAdapters]?: FieldOverride<ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>>;
+};
+type FlattenedErrors<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    -readonly [K in keyof ValuePathsToAdapters]?: ErrorTypeOfFieldAdapter<ValuePathsToAdapters[K]>;
+};
+type ValuePathsToAdaptersOf<TypePathsToAdapters extends Partial<Readonly<Record<string, FieldAdapter>>>, ValuePathsToTypePaths extends Readonly<Record<string, string>>> = keyof TypePathsToAdapters extends ValueOf<ValuePathsToTypePaths> ? {
+    readonly [K in keyof ValuePathsToTypePaths as unknown extends TypePathsToAdapters[ValuePathsToTypePaths[K]] ? never : K]: NonNullable<TypePathsToAdapters[ValuePathsToTypePaths[K]]>;
+} : never;
+declare class FormPresenter<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValueTypesOf<T, '*'>, ValueTypeOf<ReadonlyTypeDefOf<T>>>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
+    readonly typeDef: T;
+    private readonly adapters;
+    constructor(typeDef: T, adapters: TypePathsToAdapters);
+    private maybeGetAdapterForValuePath;
+    private getAdapterForValuePath;
+    typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K];
+    setFieldValueAndValidate<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, value: ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
+    setFieldValue<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, value: ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
+    addListItem<K extends keyof FlattenedListTypeDefsOf<T>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, elementValue: Maybe<ElementOfArray<FlattenedValueTypesOf<T>[K]>>, index?: number): void;
+    removeListItem<K extends keyof FlattenedListTypeDefsOf<T>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, elementValuePath: `${K}.${number}`): void;
+    private internalSetFieldValue;
+    clearFieldError<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): void;
+    clearFieldValue<K extends StringKeyOf<ValuePathsToAdapters>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): void;
+    clearAll(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, value: ValueTypeOf<T>): void;
+    validateField<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): boolean;
+    validateAll(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>): boolean;
+    createModel(value: ValueTypeOf<ReadonlyTypeDefOf<T>>): FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>;
+}
+declare class FormModel<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValueTypesOf<T, '*'>, ValueTypeOf<ReadonlyTypeDefOf<T>>>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
+    private readonly typeDef;
+    private readonly adapters;
+    accessor value: MobxValueTypeOf<T>;
+    accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>;
+    accessor errors: FlattenedErrors<ValuePathsToAdapters>;
+    private readonly flattenedTypeDefs;
+    constructor(typeDef: T, value: ValueTypeOf<ReadonlyTypeDefOf<T>>, adapters: TypePathsToAdapters);
+    get fields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>>;
+    private get knownFields();
+    private maybeSynthesizeFieldByValuePath;
+    private synthesizeFieldByPaths;
+    getAccessorForValuePath(valuePath: keyof ValuePathsToAdapters): Accessor | undefined;
+    get accessors(): Readonly<Record<string, Accessor>>;
+    protected isDisabled(_valuePath: keyof ValuePathsToAdapters): boolean;
+    protected isRequired(_valuePath: keyof ValuePathsToAdapters): boolean;
+}
+
+/**
+ * Used to extract the supported value paths from a presenter
+ */
+type ValuePathsOfPresenter<Presenter extends FormPresenter<any, any, any, any>> = Presenter extends FormPresenter<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? keyof ValuePathsToAdapters : never;
+/**
+ * Used to extract the render type (so the value that is passed to the view) of a given value path
+ * from a presenter
+ */
+type ToTypeOfPresenterValuePath<Presenter extends FormPresenter<any, any, any, any>, K extends ValuePathsOfPresenter<Presenter>> = Presenter extends FormPresenter<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? ToTypeOfFieldAdapter<ValuePathsToAdapters[K]> : never;
+/**
+ * Extracts the form fields from the presenter. The recommended way is to
+ * define the form fields explicitly and use that type to enforce the types
+ * of your converters, but generating the FormFields from your presenter
+ * is less typing, albeit at the cost of potentially getting type errors
+ * reported a long way away from the source
+ */
+type FormFieldsOfPresenter<Presenter extends FormPresenter<any, any, any, any>> = Presenter extends FormPresenter<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? FlattenedConvertedFieldsOf<ValuePathsToAdapters> : never;
+
+type FormProps<F extends Fields> = {
+    fields: F;
+    onFieldValueChange<K extends keyof F>(this: void, key: K, value: F[K]['value']): void;
+    onFieldFocus?(this: void, key: keyof F): void;
+    onFieldBlur?(this: void, key: keyof F): void;
+    onFieldSubmit?(this: void, key: keyof F): boolean | void;
+};
+type EditorProps<O> = {
+    value: O;
+    onValueChange: (value: O) => void;
+};
+
+declare class IntegerToStringConverter<E, ValuePath extends string, Context> implements TwoWayFieldConverter<number, string, E, ValuePath, Context> {
+    private readonly isNanError;
+    constructor(isNanError: E);
+    convert(from: number): string;
+    revert(from: string): FieldConversion<number, E>;
+}
+
+declare class NullableToBooleanConverter<T extends Type, E, ValuePath extends string, Context> implements TwoWayFieldConverterWithValueFactory<ValueTypeOf<ReadonlyTypeDefOf<T>> | null, boolean, E, ValuePath, Context> {
+    private readonly typeDef;
+    private readonly prototype;
+    readonly defaultValue: ValueTypeOf<ReadonlyTypeDefOf<T>> | null;
+    constructor(typeDef: T, prototype: ValueTypeOf<ReadonlyTypeDefOf<T>>, defaultToNull?: boolean);
+    convert(from: ValueTypeOf<ReadonlyTypeDefOf<T>> | null): boolean;
+    revert(from: boolean): FieldConversion<ValueTypeOf<ReadonlyTypeDefOf<T>> | null, E>;
+    create(): ValueTypeOf<ReadonlyTypeDefOf<T>> | null;
+}
+
+declare abstract class AbstractSelectValueTypeConverter<T extends Type, To extends string | null, Values extends Readonly<Record<NonNullable<To>, ValueTypeOf<T>>>, NoSuchValueError, ValuePath extends string, Context> implements TwoWayFieldConverterWithValueFactory<ValueTypeOf<T>, keyof Values | null, NoSuchValueError, ValuePath, Context> {
+    protected readonly typeDef: T;
+    protected readonly values: Values;
+    private readonly defaultValueKey;
+    private readonly noSuchValueError;
+    constructor(typeDef: T, values: Values, defaultValueKey: keyof Values | null, noSuchValueError: NoSuchValueError | null);
+    revert(from: keyof Values | null): FieldConversion<ValueTypeOf<T>, NoSuchValueError>;
+    convert(from: ValueTypeOf<T>): To;
+    protected abstract doConvert(from: ValueTypeOf<T>): To;
+    create(): ValueTypeOf<T>;
+}
+declare class SelectDiscriminatedUnionConverter<U extends UnionTypeDef, To extends StringKeyOf$1<U['unions']> | null, ValuePath extends string, Context> extends AbstractSelectValueTypeConverter<Type<U>, To, ValueTypesOfDiscriminatedUnion<U>, never, ValuePath, Context> {
+    constructor(typeDef: Type<U>, values: ValueTypesOfDiscriminatedUnion<U>, defaultValueKey: keyof U['unions']);
+    protected doConvert(from: ValueTypeOf<Type<U>>): any;
+}
+declare class SelectLiteralConverter<L extends string | number | null, To extends string | null, Values extends Record<NonNullable<L>, NonNullable<To>>, NoSuchValueError, ValuePath extends string, Context> extends AbstractSelectValueTypeConverter<Type<LiteralTypeDef<L>>, To, Record<NonNullable<To>, L>, NoSuchValueError, ValuePath, Context> {
+    private readonly valuesToStrings;
+    constructor(typeDef: Type<LiteralTypeDef<L>>, valuesToStrings: Values, defaultValue: L | null, noSuchValueError: NoSuchValueError | null);
+    protected doConvert(from: L): Values[NonNullable<L>];
+}
+
+declare class TrimmingStringConverter<ValuePath extends string, Context> implements TwoWayFieldConverter<string, string, never, ValuePath, Context> {
+    constructor();
+    convert(to: string): string;
+    revert(from: string): FieldConversion<string, never>;
+}
+
+declare function validatingConverter<V, E, ValuePath extends string, Context>(validators?: readonly FieldValidator<V, E, ValuePath, Context>[]): FieldConverter<V, V, E, ValuePath, Context>;
+
+declare function minimumStringLengthFieldValidatorFactory<E, ValuePath extends string, Context>(minimumLength: number, error: E): FieldValidator<string, E, ValuePath, Context>;
+
+declare function prototypingFieldValueFactory<V, ValuePath extends string, Context>(prototype: V): FieldValueFactory<V, ValuePath, Context>;
+
+type ValueTypeOfField<F extends Field> = F extends Field<infer V> ? V : never;
+
+type AllFieldsOfFields<F extends Fields> = {
+    [K in keyof F as ValueTypeOfField<F[K]> extends any ? K : never]: F[K];
+};
+
+type BooleanFieldsOfFields<F extends Fields> = {
+    [K in keyof F as ValueTypeOfField<F[K]> extends boolean ? K : never]: F[K];
+};
+
+type ErrorTypeOfField<F extends Field> = F extends Field<infer _V, infer E> ? E : never;
+
+type ListFieldsOfFields<F extends Fields> = {
+    [K in keyof F as ValueTypeOfField<F[K]> extends readonly any[] ? K : never]: F[K];
+};
+
+type StringFieldsOfFields<F extends Fields> = {
+    [K in keyof F as ValueTypeOfField<F[K]> extends string | undefined | null ? K : never]: F[K];
+};
+
+type PartialComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps = {}> = Exclude<keyof CurriedProps, keyof ComponentProps<Component>> extends never ? UnsafePartialComponent<Component, CurriedProps, AdditionalProps> : keyof CurriedProps extends (string | number) ? `unmatched prop: ${Exclude<keyof CurriedProps, keyof ComponentProps<Component>>}` : Exclude<keyof CurriedProps, keyof ComponentProps<Component>>;
+type UnsafePartialComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps = {}> = ForwardRefExoticComponent<PropsWithoutRef<RemainingComponentProps<Component, CurriedProps> & AdditionalProps>>;
+declare function createSimplePartialComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>>(Component: Component, curriedProps: CurriedProps): PartialComponent<Component, CurriedProps>;
+declare function createPartialComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>, AdditionalProps = {}>(Component: Component, curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps): PartialComponent<Component, CurriedProps, AdditionalProps>;
+declare function usePartialComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>, AdditionalProps = {}>(createCurriedProps: (additionalProps: AdditionalProps) => CurriedProps, deps: DependencyList, Component: Component): PartialComponent<Component, CurriedProps, AdditionalProps>;
+declare function createPartialObserverComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>, AdditionalProps = {}>(Component: Component, curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps): PartialComponent<Component, CurriedProps, AdditionalProps>;
+declare function createUnsafePartialObserverComponent<Component extends ComponentType<any>, CurriedProps, AdditionalProps = {}>(Component: Component, curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps): UnsafePartialComponent<Component, CurriedProps, AdditionalProps>;
+declare function usePartialObserverComponent<Component extends ComponentType<any>, CurriedProps extends Partial<ComponentProps<Component>>, AdditionalProps = {}>(curriedPropsSource: (additionalProps: AdditionalProps) => CurriedProps, deps: DependencyList, Component: Component): PartialComponent<Component, CurriedProps, AdditionalProps>;
+type RemainingComponentProps<Component extends ComponentType, CurriedProps> = Omit<ComponentProps<Component>, keyof CurriedProps> & JSX.IntrinsicAttributes;
+
+type MantineForm<F extends Fields> = {
+    fields: F;
+    onFieldValueChange: (<K extends keyof F>(this: void, key: K, value: F[K]['value']) => void) | undefined;
+    onFieldFocus: ((this: void, key: keyof F) => void) | undefined;
+    onFieldBlur: ((this: void, key: keyof F) => void) | undefined;
+    onFieldSubmit: ((this: void, key: keyof F) => boolean | void) | undefined;
+};
+type MantineFieldComponent<T, P = T> = UnsafePartialComponent<ComponentType<P>, T>;
+
+type SuppliedCheckboxProps = Pick<CheckboxProps, 'name' | 'checked' | 'disabled' | 'required' | 'error' | 'onChange' | 'onFocus' | 'onBlur' | 'onKeyUp'>;
+
+type SuppliedListProps<Value = any> = {
+    values: readonly Value[];
+};
+declare function DefaultList<Value>({ values, children, }: SuppliedListProps<Value> & {
+    children: (value: Value, index: number) => React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+type SuppliedPillProps = Pick<PillProps, 'children' | 'disabled'>;
+
+type SuppliedRadioProps = Pick<RadioProps, 'value' | 'disabled'>;
+
+type SuppliedRadioGroupProps = Pick<RadioGroupProps, 'name' | 'value' | 'required' | 'error' | 'onChange' | 'onFocus' | 'onBlur' | 'onKeyUp'>;
+
+type TextInputTarget = Element & {
+    value: string;
+};
+type SuppliedTextInputProps<T extends TextInputTarget = TextInputTarget> = Partial<{
+    name: string;
+    value: string | number | readonly string[] | undefined;
+    disabled: boolean;
+    required: boolean;
+    onChange: (e: React.ChangeEvent<T>) => void;
+    onFocus: (e: React.FocusEvent<T>) => void;
+    onBlur: (e: React.FocusEvent<T>) => void;
+    onKeyUp: (e: React.KeyboardEvent<T>) => void;
+}>;
+
+type SuppliedValueInputProps<V, T extends Element = Element> = Partial<{
+    name: string;
+    value: V;
+    disabled: boolean;
+    required: boolean;
+    onChange: (value: V) => void;
+    onFocus: (e: React.FocusEvent<T>) => void;
+    onBlur: (e: React.FocusEvent<T>) => void;
+    onKeyUp: (e: React.KeyboardEvent<T>) => void;
+}>;
+
+declare function SimpleSelect(props: SelectProps & {
+    onChange?: (value: string | null) => void;
+}): react_jsx_runtime.JSX.Element;
+type ErrorRendererProps<E> = {
+    error: E;
+};
+type ErrorRenderer<E = any> = React.ComponentType<ErrorRendererProps<E>>;
+declare function useMantineForm<F extends Fields>({ onFieldValueChange, onFieldBlur, onFieldFocus, onFieldSubmit, fields, }: FormProps<F>): MantineFormImpl<F>;
+declare class MantineFormImpl<F extends Fields> implements MantineForm<F> {
+    private readonly textInputCache;
+    private readonly valueInputCache;
+    private readonly checkboxCache;
+    private readonly radioGroupCache;
+    private readonly radioCache;
+    private readonly pillCache;
+    private readonly listCache;
+    accessor fields: F;
+    onFieldValueChange: (<K extends keyof F>(this: void, key: K, value: F[K]['value']) => void) | undefined;
+    onFieldFocus: ((this: void, key: keyof F) => void) | undefined;
+    onFieldBlur: ((this: void, key: keyof F) => void) | undefined;
+    onFieldSubmit: ((this: void, key: keyof F) => boolean | void) | undefined;
+    constructor(fields: F);
+    textInput<K extends keyof StringFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedTextInputProps, TextInputProps>;
+    textInput<K extends keyof StringFieldsOfFields<F>, P extends SuppliedTextInputProps<any>>(valuePath: K, TextInput?: ComponentType<P>, ErrorRenderer?: ErrorRenderer<ErrorTypeOfField<F[K]>>): MantineFieldComponent<SuppliedTextInputProps, P>;
+    valueInput<K extends keyof AllFieldsOfFields<F>, P extends SuppliedValueInputProps<ValueTypeOfField<F[K]>, any>>(valuePath: K, ValueInput: ComponentType<P>, ErrorRenderer?: ErrorRenderer<ErrorTypeOfField<F[K]>>): MantineFieldComponent<SuppliedValueInputProps<ValueTypeOfField<F[K]>>, P>;
+    select<K extends keyof StringFieldsOfFields<F>>(valuePath: K, ErrorRenderer?: ErrorRenderer<ErrorTypeOfField<F[K]>>): MantineFieldComponent<SuppliedTextInputProps, ComponentProps<typeof SimpleSelect>>;
+    checkbox<K extends keyof BooleanFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedCheckboxProps, CheckboxProps>;
+    checkbox<K extends keyof BooleanFieldsOfFields<F>, P extends SuppliedCheckboxProps>(valuePath: K, Checkbox: ComponentType<P>, ErrorRenderer?: ErrorRenderer<ErrorTypeOfField<F[K]>>): MantineFieldComponent<SuppliedCheckboxProps, P>;
+    radioGroup<K extends keyof StringFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedRadioGroupProps, RadioGroupProps>;
+    radioGroup<K extends keyof StringFieldsOfFields<F>, P extends SuppliedRadioGroupProps>(valuePath: K, RadioGroup: ComponentType<P>, ErrorRenderer?: ErrorRenderer<ErrorTypeOfField<F[K]>>): MantineFieldComponent<SuppliedRadioGroupProps, P>;
+    radio<K extends keyof StringFieldsOfFields<F>>(valuePath: K, value: ValueTypeOfField<F[K]>): MantineFieldComponent<SuppliedRadioProps, RadioProps>;
+    radio<K extends keyof StringFieldsOfFields<F>, P extends SuppliedRadioProps>(valuePath: K, value: ValueTypeOfField<F[K]>, Radio: ComponentType<P>): MantineFieldComponent<SuppliedRadioProps, P>;
+    pill<K extends keyof AllFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedPillProps, PillProps>;
+    pill<K extends keyof AllFieldsOfFields<F>, P extends SuppliedPillProps>(valuePath: K, Pill: ComponentType<P>): MantineFieldComponent<SuppliedPillProps, P>;
+    list<K extends keyof ListFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedListProps<ElementOfArray<F[K]>>, ComponentProps<typeof DefaultList<ElementOfArray<F[K]>>>>;
+}
+
+/**
+ * Maps type paths to value paths for
+ */
+type FlattenedFormFieldsOf<JsonPaths extends Record<string, string>, TypePathsToFormFields extends Partial<Readonly<Record<ValueOf<JsonPaths>, Field>>>> = keyof TypePathsToFormFields extends ValueOf<JsonPaths> ? {
+    readonly [K in keyof JsonPaths as unknown extends TypePathsToFormFields[JsonPaths[K]] ? never : K]: TypePathsToFormFields[JsonPaths[K]];
+} : `fields missing paths: ${PrintableOf<Exclude<keyof TypePathsToFormFields, ValueOf<JsonPaths>>>}`;
+
+export { AbstractSelectValueTypeConverter, type EditorProps, type ErrorRenderer, type ErrorRendererProps, type Field, type Fields, type FlattenedAdaptersOfFields, type FlattenedConvertedFieldsOf, type FlattenedFormFieldsOf, type FlattenedTypePathsToAdaptersOf, type FormFieldsOfPresenter, FormModel, FormPresenter, type FormProps, IntegerToStringConverter, NullableToBooleanConverter, type PartialComponent, SelectDiscriminatedUnionConverter, SelectLiteralConverter, type ToTypeOfPresenterValuePath, TrimmingStringConverter, type UnsafePartialComponent, type ValuePathsOfPresenter, type ValuePathsToAdaptersOf, adapter, adapterFromPrototype, adapterFromTwoWayConverter, createPartialComponent, createPartialObserverComponent, createSimplePartialComponent, createUnsafePartialObserverComponent, identityAdapter, listAdapter, minimumStringLengthFieldValidatorFactory, prototypingFieldValueFactory, useMantineForm, usePartialComponent, usePartialObserverComponent, validatingConverter };