@sealcode/sealgen 0.19.26 → 0.19.29

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

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

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

@@ -0,0 +1,23 @@
+import Router from "@koa/router";
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { FormMessage, FormData } from "../form-types.js";
+import type { Form } from "../form.js";
+export type FieldMessages<Fieldnames extends string = string> = Record<Fieldnames, {
+    type: "error" | "info";
+    message: string;
+}>;
+export declare class FormControlContext {
+    ctx: Context;
+    data: FormData;
+    messages: FormMessage[];
+    field_name_prefix: string;
+    form_id: string;
+    validate: boolean;
+    constructor(ctx: Context, data: FormData, 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, _form: Form<any, any>): 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/hybrid.d.ts

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

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

@@ -0,0 +1,19 @@
+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 { FilePointer } from "@sealcode/file-manager";
+export declare class Image extends File {
+    field: FormField<boolean, FileContainer>;
+    constructor(field: FormField<boolean, FileContainer>, 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/src/forms/controls/image.test.d.ts

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

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

@@ -0,0 +1,42 @@
+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 | undefined;
+    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>;
+    setLabel(label: string): void;
+    setUploadLabel(label: string): void;
+    setAdditionalFieldsGetter(fn: (ctx: Context, file: FilePointer) => Promise<Record<string, unknown>>): void;
+}

package/@types/src/forms/controls/multiple-images.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 MultipleImages 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/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 {
+    field: NumberField;
+    options: NumberOptions;
+    constructor(field: NumberField, options: NumberOptions);
+    getType(): string;
+    getInputAttributes(fctx: FormControlContext): Promise<Record<string, string | boolean>>;
+}

package/@types/src/forms/controls/password-with-generator.d.ts

@@ -0,0 +1,6 @@
+import { FormField } from "../../index.js";
+import { SimpleInput } from "./simple-input.js";
+export declare class PasswordWithGenerator extends SimpleInput {
+    constructor(field: FormField);
+    preInput(): Promise<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/simple-input.d.ts

@@ -0,0 +1,35 @@
+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?: string;
+    value?: string;
+    placeholder?: string;
+    readonly?: boolean;
+    step?: number;
+    suffix?: string;
+    pattern?: string;
+    inputmode?: string;
+};
+export declare class SimpleInput<Options extends SimpleInputOptions = SimpleInputOptions> extends FormFieldControl {
+    field: FormField<boolean, any>;
+    options: SimpleInputOptions;
+    constructor(field: FormField<boolean, any>, 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/src/forms/controls/single-reference.d.ts

@@ -0,0 +1,14 @@
+import { FieldTypes as SealiousFieldTypes } from "sealious";
+import { CollectionField } from "../fields/collection-field.js";
+import { DropdownOptions, FreeformDropdown } from "./dropdown.js";
+import { Collection, CollectionItem } from "sealious";
+export declare class SingleReferenceDropdown<TargetCollection extends Collection, F extends SealiousFieldTypes.SingleReference, 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;
+    });
+    setOptionLabelGetter(getter: (item: CollectionItem<TargetCollection>) => string): this;
+}

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

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

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

@@ -0,0 +1,41 @@
+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>> = {
+    subfield_controls: {
+        [field_name in keyof F]: FormControl;
+    };
+    allow_removing?: boolean;
+    allow_reordering?: 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 const TABLE_COLUMN_FIELD_INDEX_PLACEHOLDER = "TABLE_ROW_INDEX________________";
+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;
+    setAllowRemoving(value: boolean): this;
+    setAllowAdding(value: boolean): this;
+    setLabel(value: string): this;
+    setRemoveLabel(value: string): this;
+    setAddLabel(value: string): this;
+    setAllowReordering(value: boolean): this;
+}

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 extends SimpleInput {
+    field: FormField<boolean>;
+    options: SimpleInputOptions & {
+        label?: string;
+        rows?: number;
+        cols?: number;
+        description?: string;
+        autogrow?: boolean;
+    };
+    constructor(field: FormField<boolean>, 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,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/src/forms/fields/boolean.d.ts

@@ -0,0 +1,22 @@
+import { Context } from "koa";
+import { Checkbox } from "../controls/checkbox.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+import { FormControlContext } from "../controls/form-control.js";
+export declare class Boolean<Required extends boolean> extends FormField<Required, boolean, Checkbox> {
+    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;
+    getControl(): Checkbox;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<boolean>;
+    sealiousValueToForm(_: Context, value: boolean | null): Promise<FormDataValue>;
+}

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,23 @@
+import { Context } from "koa";
+import { CheckboxedListInput } from "../controls/checkboxed-list-input.js";
+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, Values extends string> extends FormField<Required, Record<Values, "on">, CheckboxedListInput<Values>> {
+    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">;
+    getControl(): CheckboxedListInput<Values>;
+}

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

@@ -0,0 +1,22 @@
+import { Context } from "koa";
+import { ExtractFieldDecoded, Field } from "sealious";
+import { SimpleInput } from "../controls/controls.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField, FormFieldValidationResponse } from "./field.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+export declare class CollectionField<F extends Field<any>, Required extends boolean> extends FormField<Required, ExtractFieldDecoded<F> | null, SimpleInput> {
+    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>;
+    getControl(): SimpleInput;
+    generateFieldDeclaration(field_info: ExtractedFieldInfo, vars: {
+        form_field_types: string;
+        sealious_field: string;
+    }): string;
+}

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

@@ -0,0 +1,4 @@
+import { TextBasedSimpleField } from "./simple-form-field.js";
+export declare class Color<Required extends boolean> extends TextBasedSimpleField<Required> {
+    constructor(required: Required);
+}

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

@@ -0,0 +1,14 @@
+import { Context } from "koa";
+import { FormControl, FormControlContext } from "../controls/form-control.js";
+import { SimpleInput } from "../controls/simple-input.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult } from "./field.js";
+import { SimpleFormField } from "./simple-form-field.js";
+export declare class Coordinates<Required extends boolean, DefaultControl extends FormControl = SimpleInput> extends SimpleFormField<Required, DefaultControl, [number, number]> {
+    parse(_: Context, raw_value: FormDataValue): Promise<FieldParseResult<[number, number]>>;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<[number, number] | undefined>;
+    postSealiousCreate(): Promise<void>;
+    postSealiousEdit(): Promise<void>;
+    getControl(): DefaultControl;
+    getEmptyValue(): [number, number];
+}

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

@@ -0,0 +1,13 @@
+import { Context } from "koa";
+import { FormControlContext } from "../controls/form-control.js";
+import { SimpleInput, SimpleInputOptions } from "../controls/simple-input.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult } from "./field.js";
+import { SimpleFormField } from "./simple-form-field.js";
+export declare class DateField<Required extends boolean> extends SimpleFormField<Required, SimpleInput, Date> {
+    constructor(required: Required);
+    getEmptyValue(): Date;
+    parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<Date>>;
+    getControl(): SimpleInput<SimpleInputOptions>;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<string | null>;
+}

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

@@ -0,0 +1,14 @@
+import { Context } from "koa";
+import { SimpleInput } from "../controls/controls.js";
+import { FormControlContext } from "../controls/form-control.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult } from "./field.js";
+import { SimpleFormField } from "./simple-form-field.js";
+export declare class DateTime<Required extends boolean> extends SimpleFormField<Required, SimpleInput, Date | null> {
+    constructor(required: Required);
+    getEmptyValue(): Date | null;
+    parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<Date | null>>;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<number | null>;
+    getControl(): SimpleInput;
+    sealiousValueToForm(ctx: Context, value: number | null): Promise<FormDataValue>;
+}

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

@@ -0,0 +1,20 @@
+import { Context } from "koa";
+import { CollectionItem, FieldTypes as SealiousFieldTypes } from "sealious";
+import { FormDataValue, FormData } from "../form-types.js";
+import { CheckboxedListField } from "./checkboxed-list.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+export declare class DeepReverseSingleReferenceList extends CheckboxedListField<false, string> {
+    sealious_field: SealiousFieldTypes.DeepReverseSingleReference;
+    item_label_getter: (item: CollectionItem<any>) => string;
+    constructor(sealious_field: SealiousFieldTypes.DeepReverseSingleReference);
+    setItemLabelGetter(getter: (item: CollectionItem<any>) => string): void;
+    getSealiousCreateValue(): never;
+    postSealiousCreate(ctx: Context, created_item: CollectionItem<any>, form_data: FormData): Promise<void>;
+    postSealiousEdit(ctx: Context, edited_item: CollectionItem<any>, value: FormData): Promise<void>;
+    sealiousValueToForm(_ctx: Context, value: string[] | null): Promise<FormDataValue>;
+    generateFieldDeclaration(_field_info: ExtractedFieldInfo, vars: {
+        form_field_types: string;
+        sealious_field: string;
+    }): string;
+    generateCreateValueGetter(field_info: ExtractedFieldInfo): string;
+}

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

@@ -0,0 +1,16 @@
+import { FieldTypes as SealiousFieldTypes, CollectionItem } from "sealious";
+import { Table } from "./table.js";
+import { Table as TableControl } from "../controls/table.js";
+import { Context } from "koa";
+import { FormDataValue, FormData } from "../form-types.js";
+import { FormControlContext } from "../controls/form-control.js";
+import { FormField } from "./field.js";
+export declare class DeepReverseSingleReferenceTable extends Table<Record<string, FormField>> {
+    sealious_field: SealiousFieldTypes.DeepReverseSingleReference;
+    constructor(sealious_field: SealiousFieldTypes.DeepReverseSingleReference);
+    getControl(): TableControl<any>;
+    getSealiousCreateValue(_fctx: FormControlContext): Promise<unknown>;
+    postSealiousCreate(ctx: Context, created_item: CollectionItem<any>, form_data: FormData): Promise<void>;
+    postSealiousEdit(ctx: Context, edited_item: CollectionItem<any>, form_data: FormData): Promise<void>;
+    sealiousValueToForm(ctx: Context, _value: string[], item: CollectionItem<any>): Promise<FormDataValue>;
+}

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

@@ -0,0 +1,10 @@
+import { RegExpField } from "./regexp.js";
+import { SimpleInput } from "../controls/controls.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);
+    setErrorMessage(message: string): void;
+    getControl(): SimpleInput;
+}

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

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

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

@@ -0,0 +1,16 @@
+import { FieldTypes as SealiousFieldTypes } from "sealious";
+import { Context } from "koa";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+import { CheckboxedListField } from "./checkboxed-list.js";
+import { FormControlContext } from "../controls/form-control.js";
+import { FormDataValue } from "../form-types.js";
+export declare class EnumMultipleSealious<Values extends string> extends CheckboxedListField<boolean, Values> {
+    sealious_field: SealiousFieldTypes.EnumMultiple<Values>;
+    constructor(sealious_field: SealiousFieldTypes.EnumMultiple<Values>);
+    generateFieldDeclaration(field_info: ExtractedFieldInfo, vars: {
+        form_field_types: string;
+        sealious_field: string;
+    }): string;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<Values[]>;
+    sealiousValueToForm(ctx: Context, sealious_value: Values[] | null): Promise<FormDataValue>;
+}

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