/// <reference types="node" />
import { FormikErrors, FormikProps, FormikTouched } from 'formik';
import { GetServerSidePropsContext } from 'next';
import qs from 'querystring';
import { ReactNode } from 'react';
import * as Stream from 'stream';
import * as z from 'zod';
import { ZodRawShape } from 'zod/lib/src/types/base';
export interface MockIncomingMessage extends Stream.Readable {
    method: string;
    url: string;
}
export interface MockGetServerSidePropsContext {
    req: MockIncomingMessage;
    resolvedUrl: string;
}
declare type Primitive = string | number | boolean;
declare type DefaultValues<T> = {
    [P in keyof T]: T[P] extends Primitive ? DefaultValues<T[P]> | T[P] | '' : DefaultValues<T[P]>;
};
declare type FieldError = {
    path: (string | number)[];
    message: string;
};
declare type PostResponseError = {
    type: 'ValidationError';
    message: string;
    stack?: string | undefined;
    fieldErrors: FieldError[];
} | {
    type: 'MutationError';
    message: string;
    stack?: string | undefined;
    fieldErrors?: null;
};
declare type PostResponse<TMutationData, TValues> = {
    success: true;
    input: TValues;
    data: TMutationData;
    error?: null;
} | {
    success: false;
    input: TValues;
    data?: null;
    error: PostResponseError;
};
declare type PagePropsValue<TMutationData, TValues> = {
    endpoints: {
        /**
         * endpoint for using in `fetch()`
         */
        fetch: string;
        /**
         * endpoint for using in `<form action={x}`
         */
        action: string;
    };
    response: PostResponse<TMutationData, TValues> | null;
};
export declare function createForm<TSchema extends z.ZodObject<TSchemaShape>, TSchemaShape extends ZodRawShape, TFormId extends string>({ schema, defaultValues, formId, }: {
    schema: TSchema;
    defaultValues: DefaultValues<z.infer<TSchema>>;
    /**
     * A unique identifier for the form on the page, will used to identifiy it in the post receiver
     */
    formId: TFormId;
}): {
    formId: TFormId;
    schema: TSchema;
    getPageProps: <TMutationData, TContext extends MockGetServerSidePropsContext | GetServerSidePropsContext<qs.ParsedUrlQuery>>({ ctx, mutation, }: {
        ctx: TContext;
        mutation: (data: z.TypeOf<TSchema>) => Promise<TMutationData>;
    }) => Promise<Record<TFormId, PagePropsValue<TMutationData, z.TypeOf<TSchema>>>>;
    clientRequest: <TProps extends Record<TFormId, PagePropsValue<TMutationData_1, z.TypeOf<TSchema>>>, TMutationData_1>({ values, props }: {
        props: TProps;
        values: z.TypeOf<TSchema>;
    }) => Promise<{
        newProps: TProps;
    }>;
    getInitialValues: <TProps_1 extends Record<TFormId, PagePropsValue<TMutationData_2, z.TypeOf<TSchema>>>, TMutationData_2>(props: TProps_1) => z.TypeOf<TSchema>;
    getInitialErrors: <TProps_2 extends Record<TFormId, PagePropsValue<TMutationData_3, z.TypeOf<TSchema>>>, TMutationData_3>(props: TProps_2) => FormikErrors<z.TypeOf<TSchema>> | undefined;
    getInitialTouched: <TProps_3 extends Record<TFormId, PagePropsValue<TMutationData_4, z.TypeOf<TSchema>>>, TMutationData_4>(props: TProps_3) => FormikTouched<z.TypeOf<TSchema>> | undefined;
    getFeedbackFromProps: <TProps_4 extends Record<TFormId, PagePropsValue<TMutationData_5, z.TypeOf<TSchema>>>, TMutationData_5>(props: TProps_4) => {
        state: "success";
        error?: undefined;
    } | {
        state: "error";
        error: Error | {
            type: "ValidationError";
            message: string;
            stack?: string | undefined;
            fieldErrors: FieldError[];
        } | {
            type: "MutationError";
            message: string;
            stack?: string | undefined;
            fieldErrors?: null | undefined;
        };
    } | null;
    formikValidator: (values: z.TypeOf<TSchema>) => FormikErrors<z.TypeOf<TSchema>>;
    _unstable_useFormikScaffold: <TProps_5 extends Record<TFormId, PagePropsValue<TMutationData_6, z.TypeOf<TSchema>>>, TMutationData_6>(props: TProps_5) => {
        Form: (formProps: {
            children: (formikProps: FormikProps<z.TypeOf<TSchema>>) => ReactNode;
            onSuccess?: (({ newProps }: {
                newProps: TProps_5;
            }) => void) | undefined;
        }) => JSX.Element;
        feedback: {
            state: "success";
            error?: undefined;
        } | {
            state: "error";
            error: Error | {
                type: "ValidationError";
                message: string;
                stack?: string | undefined;
                fieldErrors: FieldError[];
            } | {
                type: "MutationError";
                message: string;
                stack?: string | undefined;
                fieldErrors?: null | undefined;
            };
        } | null;
    };
};
export {};