import { Predicate, predicates } from "@sealcode/ts-predicates";
import { Context } from "koa";
import { Collection, CollectionItem } from "sealious";
import { FormControl, FormControlContext } from "../controls/form-control.js";
import { FormDataValue, FormData } from "../form-types.js";
import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
export type FormFieldValidationResponse = {
    valid: boolean;
    message: string;
};
export type FormDisplayInfo<C extends Collection> = {
    field: keyof C["fields"];
    label: string;
    format?: (value: unknown, item: CollectionItem<C>) => JSX.Element;
};
export type FormFieldValidationFn<ValueType> = (ctx: Context, value: ValueType, field: FormField<boolean, ValueType>) => Promise<FormFieldValidationResponse>;
export type FieldParsedValue<T> = T extends FormField<infer R> ? R : never;
export type GetPredicate<F extends FormField> = F extends FormField<true> ? F["predicate"] : F["predicate"] | typeof predicates.undefined;
export type FieldsToShape<T extends Record<string, FormField>> = {
    [property in keyof T]: GetPredicate<T[property]>;
};
export declare function fieldsToShape<Fields extends Record<string, FormField>>(obj: Fields): FieldsToShape<Fields>;
export type FieldParseResult<T> = {
    parsable: true;
    error: null;
    parsed_value: T;
} | {
    parsable: false;
    error: string;
    parsed_value: null;
};
export declare abstract class FormField<Required extends boolean = boolean, ParsedValue = unknown, DefaultFormControl extends FormControl = FormControl, SealiousValue = any> {
    readonly required: Required;
    name: string;
    label: string;
    constructor(required: Required);
    predicate: Predicate;
    mapToFilter: (parsed: ParsedValue) => unknown;
    disabled: boolean;
    init(): Promise<void>;
    setName(name: string): this;
    setDisabled(status: boolean): this;
    setLabel(label: string): this;
    _validate(ctx: Context, value: ParsedValue): Promise<FormFieldValidationResponse>;
    abstract getEmptyValue(): ParsedValue;
    isValueValid(_ctx: Context, _value: ParsedValue): Promise<FormFieldValidationResponse>;
    abstract parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<ParsedValue>>;
    getParsedValue(ctx: Context, all_form_values: Record<string, FormDataValue>, validate: true): Promise<{
        valid: boolean;
        message: string;
        parsed: ParsedValue | null;
        raw: FormDataValue;
    }>;
    getParsedValue(ctx: Context, all_form_values: Record<string, FormDataValue>, validate?: false): Promise<{
        message: string;
        parsed: ParsedValue | null;
        raw: FormDataValue;
    }>;
    setMapToFilter(fn: (parsed: ParsedValue) => unknown): this;
    getDatabaseValue(ctx: Context, data: Record<string, FormDataValue>): Promise<unknown>;
    abstract getControl(): DefaultFormControl;
    getSealiousCreateValue(fctx: FormControlContext): Promise<SealiousValue>;
    sealiousValueToForm(ctx: Context, sealiousValue: SealiousValue | null, item: CollectionItem<any>): Promise<FormDataValue>;
    postSealiousCreate(ctx: Context, created_item: CollectionItem<any>, form_data: FormData): Promise<void>;
    postSealiousEdit(ctx: Context, edited_item: CollectionItem<any>, form_data: FormData): Promise<void>;
    generateFieldDeclaration(field_info: ExtractedFieldInfo, vars: {
        form_field_types: string;
        sealious_field: string;
    }): string;
    generateCreateValueGetter(field_info: ExtractedFieldInfo, vars: {
        form_field_types: string;
        sealious_field: string;
        form_fields: string;
    }): string;
    generateInitialValue(field_info: ExtractedFieldInfo, vars: {
        form_field_types: string;
        form_fields: string;
    }): string;
    generateImportsForFieldList(field_info: ExtractedFieldInfo): {
        what: string;
        from: string;
        as?: string;
        type?: boolean;
    }[];
}