@sealcode/sealgen 0.18.2 → 0.18.5

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

@@ -0,0 +1,40 @@
+/// <reference types="koa__router" resolution-mode="require"/>
+import Router from "@koa/router";
+import { Collection, CollectionItem, 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";
+import { FilePointer } from "@sealcode/file-manager";
+export type MultipleFilesOptions = {
+    label?: string;
+    uploadLabel?: string;
+    getAdditionalFields: (ctx: Context, file: FilePointer) => 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: FilePointer): Promise<void>;
+    getFrameRelativeURL(): string;
+    getFrameID(): string;
+    renderFrame(_ctx: Context, content?: FlatTemplatable): string | Promise<string>;
+    render(fctx: FormControlContext): FlatTemplatable | Promise<FlatTemplatable>;
+    getReferencingCollection(): Collection;
+    getFileField(): SealiousField<any> | null;
+    extractFileFromItem(item: CollectionItem<Collection>): Promise<FilePointer | null>;
+    renderFileItemPreview(_fileItem: CollectionItem, file: FilePointer): Promise<FlatTemplatable>;
+    renderFileItem(fileItem: CollectionItem, file: FilePointer): 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/forms/controls/multiple-photos.d.ts

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

package/@types/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/forms/controls/photo.d.ts

@@ -0,0 +1,21 @@
+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 { FileContainer } from "../fields/file.js";
+import { KoaResponsiveImageRouter } from "koa-responsive-image-router";
+import { FilePointer } from "@sealcode/file-manager";
+export declare class Photo extends File {
+    field: FormField<boolean, FileContainer>;
+    imageRouter: KoaResponsiveImageRouter;
+    constructor(field: FormField<boolean, FileContainer>, imageRouter: KoaResponsiveImageRouter, options?: SimpleInputOptions);
+    getImgStyle(): Promise<string>;
+    renderFilePreview(_ctx: Context, file: FilePointer | null): Promise<FlatTemplatable>;
+    getWrapperModifiers(): string[];
+    getInputAttributes(fctx: FormControlContext): Promise<{
+        accept: string;
+        onchange: string;
+    }>;
+}

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

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

package/@types/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/forms/controls/reverse-single-reference.d.ts

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

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

@@ -0,0 +1,33 @@
+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: FormControlContext, _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>;
+    getWrapperModifiers(): string[];
+    render(fctx: FormControlContext): Promise<FlatTemplatable>;
+}

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

@@ -0,0 +1,13 @@
+import SealiousSingleReference from "sealious/@types/src/app/base-chips/field-types/single-reference.js";
+import { CollectionField } from "../fields/collection-field.js";
+import { DropdownOptions, FreeformDropdown } from "./dropdown.js";
+import { Collection, CollectionItem } from "sealious";
+export declare class SingleReferenceDropdown<F extends SealiousSingleReference, Required extends boolean> extends FreeformDropdown {
+    field: CollectionField<F, Required>;
+    options: DropdownOptions & {
+        getLabel?: (item: CollectionItem<Collection>) => string;
+    };
+    constructor(field: CollectionField<F, Required>, options?: DropdownOptions & {
+        getLabel?: (item: CollectionItem<Collection>) => string;
+    });
+}

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

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

package/@types/forms/controls/table.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="koa__router" resolution-mode="require"/>
+import Router from "@koa/router";
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { FormField } from "../fields/field.js";
+import { Table as TableField } from "../fields/table.js";
+import { Form } from "../form.js";
+import { FormControl, FormControlContext } from "./form-control.js";
+export type TableControlOptions<F extends Record<string, FormField>> = {
+    render_fields: {
+        [field_name in keyof F]: (fctx: FormControlContext, name: string, value: string) => FlatTemplatable | Promise<FlatTemplatable>;
+    };
+    allow_removing?: boolean;
+    label_add?: string;
+    label: string;
+    label_remove?: string;
+} & ({
+    allow_adding: false;
+} | {
+    allow_adding: true;
+    make_new_row: (ctx: Context) => Promise<{
+        [field_name in keyof F]: unknown;
+    }>;
+});
+export declare class Table<F extends Record<string, FormField>> extends FormControl {
+    table_field: TableField<F>;
+    options: TableControlOptions<F>;
+    role: "input";
+    constructor(table_field: TableField<F>, options: TableControlOptions<F>);
+    render(fctx: FormControlContext): Promise<FlatTemplatable>;
+    getFrameID(): string;
+    getActionURL(field_name: string, action: Record<string, unknown>): string;
+    mount(router: Router, form: Form<any, any>): void;
+}

package/@types/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 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/forms/controls/tickable.d.ts

@@ -0,0 +1,25 @@
+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<T> = {
+    id?: string;
+    name?: string;
+    label?: string;
+    hide_errors?: boolean;
+    readonly?: boolean;
+    default_value: T;
+};
+export declare abstract class Tickable<T> extends FormFieldControl {
+    field: FormField<boolean, T>;
+    options: TickableOptions<T>;
+    constructor(field: FormField<boolean, T>, options: TickableOptions<T>);
+    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(fctx: FormControlContext): Promise<FlatTemplatable>;
+}

package/@types/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/forms/fields/boolean.test.d.ts

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

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

@@ -0,0 +1,21 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField, FormFieldValidationResponse } from "./field.js";
+export type CheckboxedListItem = {
+    value: string;
+    label?: string;
+    group?: string;
+};
+export declare class CheckboxedListField<Required extends boolean> extends FormField<Required, Record<string, "on">> {
+    required: Required;
+    generateOptions: (ctx: Context) => Promise<CheckboxedListItem[]>;
+    isVisible: (ctx: Context) => Promise<boolean>;
+    constructor(required: Required, generateOptions: (ctx: Context) => Promise<CheckboxedListItem[]>, 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/forms/fields/collection-field.d.ts

@@ -0,0 +1,15 @@
+import { Context } from "koa";
+import { ExtractFieldDecoded, Field } from "sealious";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField, FormFieldValidationResponse } from "./field.js";
+export declare class CollectionField<F extends Field<any>, Required extends boolean> extends FormField<Required, ExtractFieldDecoded<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<ExtractFieldDecoded<F> | null>>;
+    isValueValid(ctx: Context, value: ExtractFieldDecoded<F>): Promise<FormFieldValidationResponse>;
+    getEmptyValue(): ExtractFieldDecoded<F>;
+}

package/@types/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/forms/fields/email.test.d.ts

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

package/@types/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/forms/fields/enum-multiple.test.d.ts

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

package/@types/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/forms/fields/enum.test.d.ts

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

package/@types/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<unknown>);
+    getEmptyValue(): string;
+}

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

@@ -0,0 +1,48 @@
+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 = 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>, validate: true): Promise<{
+        valid: boolean;
+        message: string;
+        parsed: ParsedValue | null;
+        raw: FormDataValue;
+    }>;
+    getValue(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>;
+}

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

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

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

@@ -0,0 +1,16 @@
+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";
+export * from "./table.js";

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

@@ -0,0 +1,19 @@
+import { Context } from "koa";
+import { FileManager, FilePointer } from "@sealcode/file-manager";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export type FileContainer = {
+    old: FilePointer | null;
+    new: FilePointer | null;
+};
+export declare class File<Required extends boolean> extends FormField<Required, FileContainer> {
+    readonly required: Required;
+    file_manager: FileManager;
+    constructor(required: Required, file_manager: FileManager);
+    parse(_ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<FileContainer>>;
+    getDatabaseValue(ctx: Context, data: Record<string, FormDataValue>): Promise<FilePointer | undefined>;
+    getEmptyValue(): {
+        old: null;
+        new: null;
+    };
+}

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

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

package/@types/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/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/forms/fields/number.test.d.ts

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

package/@types/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/forms/fields/pick-from-list.test.d.ts

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

package/@types/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/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;
+}

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

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

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

@@ -0,0 +1,13 @@
+import { FormField } from "./field.js";
+import { FieldTypes as SealiousFields } from "sealious";
+import { Context } from "koa";
+export declare class ReverseSingleReference extends FormField {
+    sealious_field: SealiousFields.ReverseSingleReference;
+    constructor(required: boolean, sealious_field: SealiousFields.ReverseSingleReference);
+    parse(ctx: Context, raw_value: unknown): Promise<{
+        parsable: true;
+        error: null;
+        parsed_value: unknown;
+    }>;
+    getEmptyValue(): never[];
+}

package/@types/forms/fields/simple-form-field.d.ts

@@ -0,0 +1,9 @@
+import { FormDataValue } from "../form-types.js";
+import { Context } from "koa";
+import { FieldParseResult, FormField } from "./field.js";
+export declare class SimpleFormField<Required extends boolean> extends FormField<Required, string | null> {
+    parse(_: Context, raw_value: FormDataValue): Promise<FieldParseResult<string>>;
+    predicate: import("@sealcode/ts-predicates").Predicate<string>;
+    getEmptyValue(): string;
+    constructor(required: Required);
+}

package/@types/forms/fields/structured-array.d.ts

@@ -0,0 +1,14 @@
+import { Context } from "koa";
+import { Field, FieldsetOutput, FieldTypes } from "sealious";
+import { FormDataValue } from "../form-types.js";
+import { FormField } from "./field.js";
+export declare class StructuredArrayField<Fields extends Record<string, Field<unknown>>> extends FormField<true, FieldTypes.ArrayStorageInput<FieldsetOutput<Fields>>> {
+    sealious_field: FieldTypes.StructuredArray<Fields>;
+    constructor(sealious_field: FieldTypes.StructuredArray<Fields>);
+    parse(_context: Context, value: FormDataValue): Promise<{
+        parsable: true;
+        error: null;
+        parsed_value: FieldsetOutput<Fields>;
+    }>;
+    getEmptyValue(): FieldTypes.ArrayStorageInput<FieldsetOutput<Fields>>;
+}

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

@@ -0,0 +1,13 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export type ExtractFormFieldParsed<Field extends FormField> = Field extends FormField<true, infer T> ? NonNullable<T> : Field extends FormField<true, infer T> ? T : never;
+export type TableFieldParsed<F extends Record<string, FormField>> = {
+    [field_name in keyof F]: ExtractFormFieldParsed<F[field_name]>;
+}[];
+export declare class Table<F extends Record<string, FormField>> extends FormField<false, TableFieldParsed<F>> {
+    columns: F;
+    constructor(columns: F);
+    getEmptyValue(): never[];
+    parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<TableFieldParsed<F>>>;
+}