import { FragmentFieldConfig, ListFieldConfig, ObjectConfig, ObjectFieldConfig, ValueFieldConfig } from "./config";
import { Fragment, ObjectState } from "./fields/objectField";
import { Rule } from "./rules";
import { Builtin, OmitIf } from "./utils";
/**
 * Provides a Zod-ish API for building form configs.
 */
export declare const f: {
    /** Creates the top-level config for a form, like an author or book. */
    config<T>(fields: ObjectConfigBuilderFields<T>): ObjectConfig<T>;
    /** Creates the config DSL for an object, like an author or book. */
    object<T>(fields: ObjectConfigBuilderFields<T>): ObjectConfigBuilder<T>;
    /** Creates the config DSL for an list of objects, like an author's list of books. */
    list<U>(fields: ObjectConfigBuilderFields<U>): ListFieldConfigBuilder<U>;
    /** Creates the config DSL for a primitive value, like a first name or phone number. */
    value<V>(): ValueFieldConfigBuilder<V>;
    /** A shortcut for creating a child object with a single `id` key. */
    reference<V extends {
        id?: unknown;
    }>(fields?: ObjectConfigBuilderFields<V>): ObjectConfigBuilder<V>;
    /** A shorthand for creating a computed value. */
    computed<V>(): ValueFieldConfigBuilder<V>;
};
/**
 * Defines the fields that should be passed into `f.object({ ... })` for fhe form type `T`.
 *
 * This is basically a map of `key` in `T` to `f.value()`, `f.list()`, or `f.object()`
 * DSL objects that define the runtime structure/fields of the form.
 */
export type ObjectConfigBuilderFields<T> = {
    [P in keyof OmitIf<T, Function>]: T[P] extends Fragment<infer V> ? FragmentFieldConfigBuilder : T[P] extends Array<infer U> | null | undefined ? U extends Builtin ? ValueFieldConfigBuilder<T[P]> : ListFieldConfigBuilder<U> : ValueFieldConfigBuilder<T[P]> | ObjectConfigBuilder<T[P]>;
};
export interface FragmentFieldConfigBuilder {
    build(): FragmentFieldConfig;
}
/** Provides a fluent DSL for building up an object's config. */
export declare class ObjectConfigBuilder<T> {
    private config;
    constructor(fields: ObjectConfigBuilderFields<T>);
    ref(): this;
    build(): ObjectFieldConfig<T>;
}
/** Provides a fluent DSL for building up a value's config. */
export declare class ValueFieldConfigBuilder<V> {
    private config;
    /** Marks the field as required. */
    req(): this;
    /** Marks the field as read only. */
    readOnly(): this;
    /** Marks the field as local only. */
    localOnly(): this;
    /** Appends `rules` to the field's validation rules. */
    rules(rules: Rule<V | null | undefined>[]): this;
    /** Marks the field as computed. */
    computed(): this;
    build(): ValueFieldConfig<V>;
}
/** Provides a fluent DSL for building up a list's config. */
export declare class ListFieldConfigBuilder<U> {
    private config;
    constructor(fields: ObjectConfigBuilderFields<U>);
    /** Appends `rule` to the field's validation rules. */
    rule(rule: Rule<readonly ObjectState<U>[]>): this;
    /** Appends `rules` to the field's validation rules. */
    rules(rules: Rule<readonly ObjectState<U>[]>[]): this;
    build(): ListFieldConfig<U>;
}