@sealcode/sealgen 0.11.7 → 0.12.0

package/@types/src/forms/controls/field-group.d.ts

@@ -0,0 +1,23 @@
+import { FlatTemplatable } from "tempstream";
+import { FormControl, FormControlContext } from "./form-control.js";
+import { FormFieldControl } from "./form-field-control.js";
+export declare class FieldGroup extends FormFieldControl {
+    controls: FormControl[];
+    options: {
+        label?: string;
+        classes?: string[];
+        containerID?: string;
+    };
+    constructor(controls: FormControl[], options?: {
+        label?: string;
+        classes?: string[];
+        containerID?: string;
+    });
+    preLabel(): FlatTemplatable;
+    preLabelContainer(): FlatTemplatable;
+    postLabel(): FlatTemplatable;
+    preFields(): FlatTemplatable;
+    postFields(): FlatTemplatable;
+    getGroupLabelProps(): FlatTemplatable;
+    render(fctx: FormControlContext): Promise<FlatTemplatable>;
+}

package/@types/src/forms/controls/file.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { FileContainer } from "../fields/file.js";
+import { FormDataValue } from "../form-types.js";
+import { FormControlContext } from "./form-control.js";
+import { SimpleInput } from "./simple-input.js";
+export declare class File extends SimpleInput<FileContainer> {
+    getType(): string;
+    renderFilePreview(_ctx: Context, file_data: {
+        id?: string;
+        filename?: string;
+    } | null): Promise<FlatTemplatable>;
+    preInput(ctx: Context, data: Record<string, FormDataValue>): Promise<import("stream").Readable>;
+    getInputAttributes(fctx: FormControlContext): Promise<Record<string, string | boolean>>;
+}

package/@types/src/forms/controls/form-control.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="koa__router" resolution-mode="require"/>
+import Router from "@koa/router";
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { FormDataValue, FormMessage } from "../form-types.js";
+export declare class FormControlContext {
+    ctx: Context;
+    data: Record<string, FormDataValue>;
+    messages: FormMessage[];
+    field_name_prefix: string;
+    form_id: string;
+    validate: boolean;
+    constructor(ctx: Context, data: Record<string, FormDataValue>, messages: FormMessage[], field_name_prefix: string, form_id: string, validate: boolean);
+}
+export declare abstract class FormControl {
+    abstract render(fctx: FormControlContext): FlatTemplatable | Promise<FlatTemplatable>;
+    abstract role: "input" | "decoration" | "messages" | "submit";
+    mount(router: Router): void;
+}

package/@types/src/forms/controls/form-field-control.d.ts

@@ -0,0 +1,13 @@
+import { FlatTemplatable } from "tempstream";
+import { FormField } from "../fields/field.js";
+import { FieldValueType } from "../form-types.js";
+import { FormControl, FormControlContext } from "./form-control.js";
+export type FormFieldsToTypes<FormFields extends readonly FormField[]> = {
+    [Index in keyof FormFields]: FormFields[Index] extends FormField ? FieldValueType<FormFields[Index]> : never;
+};
+export declare abstract class FormFieldControl extends FormControl {
+    fields: FormField[];
+    role: "input";
+    constructor(fields: FormField[]);
+    abstract render(fctx: FormControlContext): FlatTemplatable | Promise<FlatTemplatable>;
+}

package/@types/src/forms/controls/form-header.d.ts

@@ -0,0 +1,8 @@
+import { FormControl, FormControlContext } from "./form-control.js";
+export declare class FormHeader extends FormControl {
+    text: string;
+    isVisible: (fctx: FormControlContext) => Promise<boolean>;
+    role: "decoration";
+    constructor(text: string, isVisible?: (fctx: FormControlContext) => Promise<boolean>);
+    render(fctx: FormControlContext): Promise<string>;
+}

package/@types/src/forms/controls/form-paragraph.d.ts

@@ -0,0 +1,7 @@
+import { FormControl } from "./form-control.js";
+export declare class FormParagraph extends FormControl {
+    text: string;
+    role: "decoration";
+    constructor(text: string);
+    render(): string;
+}

package/@types/src/forms/controls/frame.d.ts

@@ -0,0 +1,17 @@
+import { FlatTemplatable } from "tempstream";
+import { FormControl } from "./form-control.js";
+/**
+ * This class will render `turbo-frame` tag so that u can
+ * embed other route inside your form. This will require
+ * to add value to `data: FormData` (inside your master form
+ * render function) with key `Frame.FRAME_PATH_KEY`. Value
+ * needs to be url to route that you want to embed. If you
+ * this value wont be provided frame will redner empty string.
+ * See `src/back/routes/profile/[id].form.ts` for an example.
+ */
+export declare class Frame extends FormControl {
+    src: string;
+    constructor(src: string);
+    render(): FlatTemplatable | Promise<FlatTemplatable>;
+    role: "decoration";
+}

package/@types/src/forms/controls/hidden-input.d.ts

@@ -0,0 +1,9 @@
+import { FlatTemplatable } from "tempstream";
+import { FormField } from "../fields/field.js";
+import { FormControlContext } from "./form-control.js";
+import { FormFieldControl } from "./form-field-control.js";
+export declare class HiddenInput extends FormFieldControl {
+    field: FormField;
+    constructor(field: FormField);
+    render(fctx: FormControlContext): Promise<FlatTemplatable>;
+}

package/@types/src/forms/controls/html.d.ts

@@ -0,0 +1,11 @@
+import { FlatTemplatable } from "tempstream";
+import { FormControl, FormControlContext } from "./form-control.js";
+type Renderer = ((fctx: FormControlContext) => FlatTemplatable) | FlatTemplatable;
+export declare class HTML extends FormControl {
+    role: "decoration" | "submit";
+    renderer: Renderer;
+    constructor(role: "decoration" | "submit", renderer: Renderer);
+    constructor(renderer: Renderer);
+    render(fctx: FormControlContext): Promise<FlatTemplatable>;
+}
+export {};

package/@types/src/forms/controls/multiple-files.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="koa__router" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import Router from "@koa/router";
+import { Collection, CollectionItem, File as SealiousFile, Field as SealiousField } from "sealious";
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { MultipleFiles as MultipleFilesField } from "../fields/multiple-files.js";
+import { FormFieldControl } from "./form-field-control.js";
+import { FormControlContext } from "./form-control.js";
+export type MultipleFilesOptions = {
+    label?: string;
+    uploadLabel?: string;
+    getAdditionalFields: (ctx: Context, file: SealiousFile) => Promise<Record<string, unknown>>;
+};
+export declare class MultipleFiles extends FormFieldControl {
+    field: MultipleFilesField;
+    options: MultipleFilesOptions;
+    constructor(field: MultipleFilesField, options?: Partial<MultipleFilesOptions>);
+    getClassModifiers(): string[];
+    mount(router: Router): void;
+    deleteFileAssociation(ctx: Context, file_item_id: string): Promise<void>;
+    addFileAssociation(ctx: Context, file: SealiousFile): Promise<void>;
+    getFrameRelativeURL(): string;
+    getFrameID(): string;
+    renderFrame(ctx: Context, content?: FlatTemplatable): import("stream").Readable;
+    render(fctx: FormControlContext): FlatTemplatable | Promise<FlatTemplatable>;
+    getReferencingCollection(): Collection;
+    getFileField(): SealiousField | null;
+    extractFileFromItem(item: CollectionItem): Promise<SealiousFile | null>;
+    renderFileItemPreview(_fileItem: CollectionItem, file: SealiousFile): Promise<FlatTemplatable>;
+    renderFileItem(fileItem: CollectionItem, file: SealiousFile): Promise<FlatTemplatable>;
+    renderFileRemoveButton(fileItem: CollectionItem): FlatTemplatable;
+    getFileItems(ctx: Context): Promise<CollectionItem<any>[]>;
+    getInputAttributes(): {
+        type: string;
+        name: string;
+        multiple: boolean;
+    };
+    renderFrameContent(ctx: Context): Promise<FlatTemplatable>;
+}

package/@types/src/forms/controls/multiple-photos.d.ts

@@ -0,0 +1,18 @@
+import { File as SealiousFile, CollectionItem } from "sealious";
+import { FlatTemplatable } from "tempstream";
+import { MultipleFiles, MultipleFilesOptions } from "./multiple-files.js";
+import { MultipleFiles as MultipleFilesField } from "../fields/multiple-files.js";
+import * as KoaResponsiveImageRouter from "koa-responsive-image-router";
+export declare class MultiplePhotos extends MultipleFiles {
+    field: MultipleFilesField;
+    imageRouter: KoaResponsiveImageRouter.default;
+    constructor(field: MultipleFilesField, imageRouter: KoaResponsiveImageRouter.default, options?: Partial<MultipleFilesOptions>);
+    getClassModifiers(): string[];
+    getInputAttributes(): {
+        accept: string;
+        type: string;
+        name: string;
+        multiple: boolean;
+    };
+    renderFileItem(fileItem: CollectionItem, file: SealiousFile): Promise<FlatTemplatable>;
+}

package/@types/src/forms/controls/number.d.ts

@@ -0,0 +1,13 @@
+import { NumberField } from "../fields/number.js";
+import { FormControlContext } from "./form-control.js";
+import { SimpleInput, SimpleInputOptions } from "./simple-input.js";
+export type NumberOptions = SimpleInputOptions & Partial<{
+    step: number;
+}>;
+export declare class Number extends SimpleInput<number | null> {
+    field: NumberField;
+    options: NumberOptions;
+    constructor(field: NumberField, options: NumberOptions);
+    getType(): string;
+    getInputAttributes(fctx: FormControlContext): Promise<Record<string, string | boolean>>;
+}

package/@types/src/forms/controls/photo.d.ts

@@ -0,0 +1,22 @@
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { File } from "./file.js";
+import { FormField } from "../fields/field.js";
+import { SimpleInputOptions } from "./simple-input.js";
+import { FormControlContext } from "./form-control.js";
+import * as KoaResponsiveImageRouter from "koa-responsive-image-router";
+import { FileContainer } from "../fields/file.js";
+export declare class Photo extends File {
+    field: FormField<boolean, FileContainer>;
+    imageRouter: KoaResponsiveImageRouter.default;
+    constructor(field: FormField<boolean, FileContainer>, imageRouter: KoaResponsiveImageRouter.default, options?: SimpleInputOptions);
+    getImgStyle(): Promise<string>;
+    renderFilePreview(ctx: Context, file_data: {
+        id?: string;
+        filename?: string;
+    } | null): Promise<FlatTemplatable>;
+    getInputAttributes(fctx: FormControlContext): Promise<{
+        accept: string;
+        onchange: string;
+    }>;
+}

package/@types/src/forms/controls/radio.d.ts

@@ -0,0 +1,16 @@
+import { Context } from "koa";
+import { FormField } from "../fields/field.js";
+import { FormDataValue } from "../form-types.js";
+import { Tickable } from "./tickable.js";
+export declare class Radio extends Tickable<string> {
+    field: FormField<boolean, string>;
+    value: string;
+    type: "radio";
+    constructor(field: FormField<boolean, string>, value: string, options: {
+        label?: string;
+    });
+    makeInputID(): string;
+    getValueAttribute(): string;
+    getWrapperClasses(ctx: Context, data: Record<string, FormDataValue>, value: string): string[];
+    isChecked(_ctx: Context, _data: Record<string, FormDataValue>, value: string): boolean;
+}

package/@types/src/forms/controls/reverse-single-reference.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/forms/controls/simple-input.d.ts

@@ -0,0 +1,32 @@
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { FormField } from "../fields/field.js";
+import { FormDataValue } from "../form-types.js";
+import { FormControlContext } from "./form-control.js";
+import { FormFieldControl } from "./form-field-control.js";
+export type SimpleInputOptions = {
+    id?: string;
+    label?: string;
+    autocomplete?: boolean;
+    hide_errors?: boolean;
+    type?: "color" | "date" | "email" | "file" | "month" | "number" | "password" | "search" | "tel" | "text" | "time" | "url" | "week";
+    value?: string;
+    placeholder?: string;
+    readonly?: boolean;
+    step?: number;
+    suffix?: string;
+};
+export declare class SimpleInput<ParsedValue, Options extends SimpleInputOptions = SimpleInputOptions> extends FormFieldControl {
+    field: FormField<boolean, ParsedValue>;
+    options: SimpleInputOptions;
+    constructor(field: FormField<boolean, ParsedValue>, options?: Options);
+    preInput(_ctx: Context, _data: Record<string, FormDataValue>): Promise<FlatTemplatable>;
+    getType(): string;
+    getLabel(): string;
+    getID(): string;
+    getPlaceholder(): string;
+    getInputAttributes(fctx: FormControlContext): Promise<Record<string, string | boolean>>;
+    postInput(_: Context): Promise<FlatTemplatable>;
+    renderInput(_ctx: Context, attributes_str: string, _data: Record<string, FormDataValue>): Promise<FlatTemplatable>;
+    render<Fields extends Record<string, FormField>>(fctx: FormControlContext): Promise<FlatTemplatable>;
+}

package/@types/src/forms/controls/textarea.d.ts

@@ -0,0 +1,25 @@
+import { Context } from "koa";
+import { FormField } from "../fields/field.js";
+import { FormDataValue } from "../form-types.js";
+import { FormControlContext } from "./form-control.js";
+import { SimpleInput, SimpleInputOptions } from "./simple-input.js";
+export declare class Textarea<Required extends boolean> extends SimpleInput<string | null> {
+    field: FormField<boolean, string | null>;
+    options: SimpleInputOptions & {
+        label?: string;
+        rows?: number;
+        cols?: number;
+        description?: string;
+        autogrow?: boolean;
+    };
+    constructor(field: FormField<boolean, string | null>, options?: SimpleInputOptions & {
+        label?: string;
+        rows?: number;
+        cols?: number;
+        description?: string;
+        autogrow?: boolean;
+    });
+    renderDescription(): string;
+    getInputAttributes(fctx: FormControlContext): Promise<Record<string, string | boolean>>;
+    renderInput(ctx: Context, attributes: string, data: Record<string, FormDataValue>): Promise<string>;
+}

package/@types/src/forms/controls/tickable.d.ts

@@ -0,0 +1,24 @@
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { FormField } from "../fields/field.js";
+import { FormDataValue } from "../form-types.js";
+import { FormControlContext } from "./form-control.js";
+import { FormFieldControl } from "./form-field-control.js";
+export type TickableOptions = {
+    id?: string;
+    name?: string;
+    label?: string;
+    hide_errors?: boolean;
+    readonly?: boolean;
+};
+export declare abstract class Tickable<T extends unknown> extends FormFieldControl {
+    field: FormField<boolean, T>;
+    options: TickableOptions;
+    constructor(field: FormField<boolean, T>, options?: TickableOptions);
+    type: "checkbox" | "radio";
+    abstract getValueAttribute(ctx: Context, data: Record<string, FormDataValue>, value: T): string;
+    abstract isChecked(ctx: Context, data: Record<string, FormDataValue>, value: T): boolean;
+    makeInputID(ctx: Context, data: Record<string, FormDataValue>, value: T): string;
+    getWrapperClasses(ctx: Context, data: Record<string, FormDataValue>, value: T): string[];
+    render<Fields extends Record<string, FormField>>(fctx: FormControlContext): Promise<FlatTemplatable>;
+}

package/@types/src/forms/fields/boolean.d.ts

@@ -0,0 +1,17 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export declare class Boolean<Required extends boolean> extends FormField<Required, boolean> {
+    error_message: string;
+    predicate: (v: unknown, w: unknown) => {
+        readonly match: boolean;
+        readonly wildcard: boolean;
+    };
+    constructor(required: Required, error_message?: string);
+    isValueValid(_: Context, value: boolean): Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+    parse(_: Context, value: FormDataValue): Promise<FieldParseResult<boolean>>;
+    getEmptyValue(): boolean;
+}

package/@types/src/forms/fields/boolean.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/forms/fields/checkboxed-list.d.ts

@@ -0,0 +1,20 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField, FormFieldValidationResponse } from "./field.js";
+export declare class ChekboxedListField<Required extends boolean> extends FormField<Required, Record<string, "on">> {
+    required: Required;
+    generateOptions: (ctx: Context) => Promise<Record<string, string> | {
+        [i: string]: string;
+    }>;
+    isVisible: (ctx: Context) => Promise<boolean>;
+    constructor(required: Required, generateOptions: (ctx: Context) => Promise<Record<string, string> | {
+        [i: string]: string;
+    }>, isVisible?: (ctx: Context) => Promise<boolean>);
+    predicate: (v: unknown, w: unknown) => {
+        readonly match: boolean;
+        readonly wildcard: string[];
+    };
+    isValueValid(_: Context, value: unknown): Promise<FormFieldValidationResponse>;
+    parse(_: Context, raw_value: FormDataValue): Promise<FieldParseResult<Record<string, "on">>>;
+    getEmptyValue(): Record<string, "on">;
+}

package/@types/src/forms/fields/collection-field.d.ts

@@ -0,0 +1,15 @@
+import { Context } from "koa";
+import { Depromisify, Field, FieldOutput } from "sealious";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField, FormFieldValidationResponse } from "./field.js";
+export declare class CollectionField<F extends Field, Required extends boolean> extends FormField<Required, FieldOutput<F> | null> {
+    sealiousField: F;
+    constructor(required: Required, sealiousField: F);
+    predicate: (v: unknown, w: unknown) => {
+        readonly match: true;
+        readonly wildcard: unknown;
+    };
+    parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<FieldOutput<F> | null>>;
+    isValueValid(ctx: Context, value: FieldOutput<F>): Promise<FormFieldValidationResponse>;
+    getEmptyValue(): Depromisify<ReturnType<F["decode"]>>;
+}

package/@types/src/forms/fields/email.d.ts

@@ -0,0 +1,7 @@
+import { RegExpField } from "./regexp.js";
+export declare class EmailField<Required extends boolean> extends RegExpField<Required> {
+    error_message: string;
+    default_value: string;
+    predicate: import("@sealcode/ts-predicates").Predicate<string>;
+    constructor(required: Required, error_message?: string, default_value?: string);
+}

package/@types/src/forms/fields/email.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/forms/fields/enum-multiple.d.ts

@@ -0,0 +1,18 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export declare class EnumMultipleField<Options extends readonly string[], Required extends boolean> extends FormField<Required, string[]> {
+    options: Options;
+    error_message: (options: Options) => string;
+    constructor(required: Required, options: Options, error_message?: (options: Options) => string);
+    predicate: (v: unknown, w: unknown) => {
+        readonly match: boolean;
+        readonly wildcard: Options[number];
+    };
+    isValueValid(_: Context, values: string[]): Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+    parse(_: Context, value: FormDataValue): Promise<FieldParseResult<string[]>>;
+    getEmptyValue(): string[];
+}

package/@types/src/forms/fields/enum-multiple.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/forms/fields/enum.d.ts

@@ -0,0 +1,18 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export declare class EnumField<Options extends readonly string[], Required extends boolean> extends FormField<Required, string> {
+    options: Options;
+    error_message: (options: Options) => string;
+    constructor(required: Required, options: Options, error_message?: (options: Options) => string);
+    predicate: (v: unknown, w: unknown) => {
+        readonly match: boolean;
+        readonly wildcard: Options[number];
+    };
+    isValueValid(_: Context, value: unknown): Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+    parse(_: Context, value: FormDataValue): Promise<FieldParseResult<string>>;
+    getEmptyValue(): string;
+}

package/@types/src/forms/fields/enum.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/forms/fields/existing-sealious-value.d.ts

@@ -0,0 +1,6 @@
+import { Field } from "sealious";
+import { PickFromListField } from "./pick-from-list.js";
+export declare class ExistingSealiousValue<Required extends boolean> extends PickFromListField<Required> {
+    constructor(required: Required, field: Field);
+    getEmptyValue(): string;
+}

package/@types/src/forms/fields/field.d.ts

@@ -0,0 +1,43 @@
+import { Predicate, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+export type FormFieldValidationResponse = {
+    valid: boolean;
+    message: string;
+};
+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 extends unknown = unknown> {
+    readonly required: Required;
+    name: string;
+    constructor(required: Required);
+    predicate: Predicate;
+    mapToFilter: (parsed: ParsedValue) => unknown;
+    init(fieldname: string): Promise<void>;
+    _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>>;
+    getValue(ctx: Context, all_form_values: Record<string, FormDataValue>): Promise<{
+        valid: boolean;
+        message: string;
+        parsed: ParsedValue;
+        raw: FormDataValue;
+    }>;
+    setMapToFilter(fn: (parsed: ParsedValue) => unknown): this;
+    getDatabaseValue(ctx: Context, data: Record<string, FormDataValue>): Promise<unknown>;
+}

package/@types/src/forms/fields/fields.d.ts

@@ -0,0 +1,15 @@
+export * from "./simple-form-field.js";
+export * from "./checkboxed-list.js";
+export * from "./collection-field.js";
+export * from "./number.js";
+export * from "./pick-from-list.js";
+export * from "./regexp.js";
+export * from "./email.js";
+export * from "./enum.js";
+export * from "./boolean.js";
+export * from "./enum-multiple.js";
+export * from "./existing-sealious-value.js";
+export * from "./file.js";
+export * from "./multiple-files.js";
+export * from "./reverse-single-reference.js";
+export * from "./structured-array.js";

package/@types/src/forms/fields/file.d.ts

@@ -0,0 +1,16 @@
+import { Context } from "koa";
+import { File as SealiousFile } from "sealious";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export type FileContainer = {
+    old: SealiousFile | null;
+    new: SealiousFile | null;
+};
+export declare class File<Required extends boolean> extends FormField<Required, FileContainer> {
+    parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<FileContainer>>;
+    getDatabaseValue(ctx: Context, data: Record<string, FormDataValue>): Promise<SealiousFile | undefined>;
+    getEmptyValue(): {
+        old: null;
+        new: null;
+    };
+}

package/@types/src/forms/fields/multiple-files.d.ts

@@ -0,0 +1,14 @@
+import { Context } from "koa";
+import { FieldTypes as SealiousFieldTypes } from "sealious";
+import { FormField } from "./field.js";
+export declare class MultipleFiles extends FormField<false> {
+    collection_field: SealiousFieldTypes.ReverseSingleReference;
+    getItemId: (ctx: Context) => Promise<string> | string;
+    constructor(collection_field: SealiousFieldTypes.ReverseSingleReference, getItemId: (ctx: Context) => Promise<string> | string);
+    getEmptyValue(): undefined;
+    parse(): Promise<{
+        readonly parsed_value: undefined;
+        readonly parsable: true;
+        readonly error: null;
+    }>;
+}

package/@types/src/forms/fields/number.d.ts

@@ -0,0 +1,23 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export declare class NumberField<DefaultValue extends number | null = number, Required extends boolean = boolean> extends FormField<Required, number | DefaultValue> {
+    default_value: DefaultValue;
+    options: Partial<{
+        max: number;
+        min: number;
+        decimalDigits: number;
+    }>;
+    constructor(required: Required, default_value: DefaultValue, options?: Partial<{
+        max: number;
+        min: number;
+        decimalDigits: number;
+    }>);
+    predicate: import("@sealcode/ts-predicates").Predicate<number>;
+    isValueValid(_: Context, value: unknown): Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+    parse(_: Context, value: FormDataValue): Promise<FieldParseResult<number>>;
+    getEmptyValue(): DefaultValue;
+}

package/@types/src/forms/fields/number.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/forms/fields/pick-from-list.d.ts

@@ -0,0 +1,14 @@
+import { Context } from "koa";
+import type { DropdownOption } from "../controls/dropdown.js";
+import { FormFieldValidationResponse } from "./field.js";
+import { SimpleFormField } from "./simple-form-field.js";
+export declare class PickFromListField<Required extends boolean> extends SimpleFormField<Required> {
+    required: Required;
+    generateOptions: (ctx: Context) => Promise<DropdownOption[]>;
+    customValidation: (ctx: Context, value: unknown, instance: PickFromListField<Required>) => Promise<FormFieldValidationResponse>;
+    constructor(required: Required, generateOptions: (ctx: Context) => Promise<DropdownOption[]>, customValidation?: (ctx: Context, value: unknown, instance: PickFromListField<Required>) => Promise<FormFieldValidationResponse>);
+    predicate: import("@sealcode/ts-predicates").Predicate<string>;
+    isValueValid(ctx: Context, value: string): Promise<FormFieldValidationResponse>;
+    valueInList(ctx: Context, value: unknown): Promise<FormFieldValidationResponse>;
+    getEmptyValue(): string;
+}

package/@types/src/forms/fields/pick-from-list.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/forms/fields/proxy-field.d.ts

@@ -0,0 +1,13 @@
+import { FormField } from "./field.js";
+export declare class ProxyFormField<T> extends FormField<boolean, T> {
+    name: string;
+    empty_value: T;
+    parsed_value: T;
+    constructor(required: boolean, name: string, empty_value: T, parsed_value: T);
+    getEmptyValue(): T;
+    parse(): Promise<{
+        readonly parsable: true;
+        readonly error: null;
+        readonly parsed_value: T;
+    }>;
+}

package/@types/src/forms/fields/regexp.d.ts

@@ -0,0 +1,16 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export declare class RegExpField<Required extends boolean> extends FormField<Required> {
+    regexp: RegExp;
+    error_message: string;
+    default_value: string;
+    constructor(required: Required, regexp: RegExp, error_message: string, default_value?: string);
+    predicate: import("@sealcode/ts-predicates").Predicate<string>;
+    isValueValid(_: Context, value: unknown): Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+    parse(_: Context, value: FormDataValue): Promise<FieldParseResult<string>>;
+    getEmptyValue(): string;
+}