import { ShapeToType } from "@sealcode/ts-predicates";
import { Context } from "koa";
import { FlatTemplatable } from "tempstream";
import { FieldMessages, FormControl, FormControlContext } from "../forms/controls/form-control.js";
import type { FieldsToShape, FormField } from "../forms/fields/field.js";
import type { FormDataValue, FormMessage, FormData } from "../forms/form-types.js";
import { Mountable } from "./mountable.js";
import Router from "@koa/router";
export type PageErrorMessage = {
    type: "access" | "internal";
    message: string;
};
export type Fields = Record<string, FormField<boolean, any>>;
type Resolved<T> = T extends Promise<infer X> ? X : never;
type ParsedValue<T extends FormField> = Resolved<ReturnType<T["getParsedValue"]>>["parsed"];
export declare abstract class MountableWithFields<F extends Fields = Fields> extends Mountable {
    getFields: () => F;
    fields: F;
    initialized: boolean;
    field_names_prefix: string;
    form_id: string;
    abstract getControls: (fields: F) => FormControl[];
    controls: FormControl[];
    constructor();
    /** most routes should be setup using .mount(), but mount runs before
        initialization so we don't yet have controls, app, etc ready for dynamic
        routes **/
    init(path: string, router: Router): void;
    makeFormControlContext(ctx: Context, data: FormData, validate: boolean, field_name_prefix?: string, form_id?: string): FormControlContext;
    validateValues(_ctx: Context, _data: Record<string, FormDataValue>): Promise<{
        valid: boolean;
        error: string;
    }>;
    getInitialValues(_ctx: Context): Promise<Record<string, FormDataValue>>;
    validate(ctx: Context, values: Record<string, FormDataValue>): Promise<{
        valid: boolean;
        field_errors: FieldMessages;
        form_messages: FormMessage[];
    }>;
    renderControls(fctx: FormControlContext): FlatTemplatable;
    renderError(_: Context, error: PageErrorMessage): Promise<FlatTemplatable>;
    renderMessages(_: Context, data: FormData<keyof Fields>): FlatTemplatable;
    abstract extractRawValues(ctx: Context): Promise<Record<string, FormDataValue>>;
    getParsedValues(ctx: Context): Promise<{
        [field in keyof F]: F[field] extends FormField<true> ? Exclude<ParsedValue<F[field]>, null> : ParsedValue<F[field]>;
    }>;
    getDatabaseValues(ctx: Context): Promise<ShapeToType<FieldsToShape<F>>>;
}
export {};