Function schema

Returns (
    input: EnhanceInput,
) => Promise<
    {
        form: {
            _string: (name: string) => string | null | undefined;
            array: <T>(
                name: string,
                mapper?: (
                    item: FormDataEntryValue,
                    index: number,
                    array: FormDataEntryValue[],
                ) => T,
            ) => T[] | undefined;
            array$: <T>(
                name: string,
                mapper?: (
                    item: FormDataEntryValue,
                    index: number,
                    array: FormDataEntryValue[],
                ) => T,
            ) => T[];
            basedOn: <T = unknown, R = unknown>(
                val: T,
                processor?: (val: T) => R,
            ) => R;
            boolean: (name: string) => boolean | undefined;
            boolean$: (name: string) => boolean;
            date: (
                name: string,
                parser?: (
                    formdata: FormData,
                    name: string,
                ) => string | number | Date | undefined,
            ) => Date | undefined;
            date$: (
                name: string,
                parser?: (formdata: FormData, name: string) => string | number | Date,
            ) => Date;
            enum: <E extends Record<string, any>>(
                name: string,
                _enum: E,
            ) => keyof E | undefined;
            enum$: <E extends Record<string, any>>(
                name: string,
                _enum: E,
            ) => E[keyof E];
            file: (name: string) => File | null | undefined;
            file$: (name: string) => File | undefined;
            fileRecord: (
                prefix: string,
                removePrefix?: boolean,
            ) => Record<string, File[]>;
            files: (name: string) => File[];
            has: (...names: string[]) => boolean;
            hasOneOf: (...name: string[]) => boolean;
            json: <T = unknown, F = T>(
                name: string,
                transformer?: (val: F) => T,
            ) => T | undefined;
            json$: <T = unknown, F = T>(
                name: string,
                transformer?: (val: F) => T,
            ) => T;
            jsond: (
                options: {
                    processor?: (input: any) => any;
                    transform?: (
                        value: FormDataEntryValue,
                        key: string,
                        data: FormData,
                    ) => any;
                } & (
                    | { prefix_name: string; unpack_prefixed?: true }
                    | { prefix_name?: undefined }
                ),
            ) => any;
            number: (name: string) => number | undefined;
            number$: (name: string) => number;
            onlyIf: <T = never>(
                condition: boolean,
                TRUE: T,
                FALSE?: undefined,
            ) => T | undefined;
            onlyIfArrayPresent: <T, R>(
                key: string,
                TRUE: (entries: FormDataEntryValue[]) => T,
                FALSE: R,
            ) => T | R;
            onlyIfPresent: <T = never>(
                key: string,
                TRUE: (entry: FormDataEntryValue) => T,
                FALSE?: undefined,
            ) => T | undefined;
            pattern$: (name: string, pattern: string | RegExp) => string;
            process: <T, R>(
                name: string,
                parser:
                    | ((formdata: FormData, name: string) => T)
                    | ((name: string) => T),
                processor: (val: T, name: string) => R,
            ) => R;
            record: <T = any>(
                options?: Partial<
                    {
                        filter: (value: [string, (...)[]]) => boolean;
                        transformer: (value: [string, (...) | (...)]) => [string, any];
                    },
                >,
            ) => T;
            result: InferValidator<T>;
            selector: <
                C extends
                    (
                        | {
                            [key: string]: (entries: FormDataEntryValue[], key: string) => T;
                        }
                        | { [key: string]: (entry: FormDataEntryValue, key: string) => T }
                    ) & {
                        $default?: (data: FormData) => T;
                        $error?: (error: unknown) => never;
                    },
                A extends boolean = false,
                T = any,
            >(
                cases: C,
                useArray?: A,
            ) => ReturnType<C[keyof C]> | undefined;
            selector$: <
                C extends
                    (
                        | {
                            [key: string]: (entries: FormDataEntryValue[], key: string) => T;
                        }
                        | { [key: string]: (entry: FormDataEntryValue, key: string) => T }
                    ) & {
                        $default?: (data: FormData) => T;
                        $error?: (error: unknown) => never;
                    },
                A extends boolean = false,
                T = any,
            >(
                cases: C,
                useArray?: A,
            ) => ReturnType<C[keyof C]>;
            string: (name: string) => string | undefined;
            string$: (name: string) => string;
            validate: <T extends Validator<any>>(
                schema: T,
                options?: SchemaOptions,
            ) => InferValidator<T>;
            get data(): FormData;
        };
    },
>