@defra/forms-engine-plugin 0.1.19 → 0.1.21

package/.server/client/javascripts/application.d.ts

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

package/.server/client/javascripts/file-upload.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Build the upload status URL given the current pathname and the upload ID.
+ * @param {string} pathname – e.g. window.location.pathname
+ * @param {string} uploadId
+ * @returns {string} e.g. "/form/upload-status/abc123"
+ */
+export function buildUploadStatusUrl(pathname: string, uploadId: string): string;
+export function initFileUpload(): void;
+export const MAX_POLLING_DURATION: 300;

package/.server/config/index.d.ts

@@ -0,0 +1,45 @@
+import convict, { type SchemaObj } from 'convict';
+import { type LevelWithSilent } from 'pino';
+import 'dotenv/config';
+export declare const config: convict.Config<{
+    appDir: string;
+    publicDir: string;
+    port: number;
+    env: string;
+    cdpEnvironment: string;
+    enforceCsrf: boolean;
+    isProduction: boolean;
+    isDevelopment: boolean;
+    isTest: boolean;
+    serviceName: string;
+    serviceVersion: SchemaObj<string>;
+    feedbackLink: SchemaObj<string>;
+    phaseTag: string;
+    sessionTimeout: number;
+    confirmationSessionTimeout: number;
+    sessionCookiePassword: SchemaObj<string>;
+    redis: {
+        host: SchemaObj<string>;
+        username: SchemaObj<string>;
+        password: SchemaObj<string>;
+        keyPrefix: SchemaObj<string>;
+    };
+    tracing: {
+        header: SchemaObj<string>;
+    };
+    notifyTemplateId: SchemaObj<string>;
+    notifyAPIKey: SchemaObj<string>;
+    designerUrl: SchemaObj<string>;
+    submissionUrl: SchemaObj<string>;
+    uploaderUrl: SchemaObj<string>;
+    uploaderBucketName: string;
+    log: {
+        enabled: boolean;
+        level: SchemaObj<LevelWithSilent>;
+        format: SchemaObj<"ecs" | "pino-pretty">;
+        redact: [string, string, string];
+    };
+    safelist: [string];
+    stagingPrefix: string;
+    submissionEmailAddress: SchemaObj<string>;
+}>;

package/.server/index.d.ts

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

package/.server/server/common/helpers/logging/logger-options.d.ts

@@ -0,0 +1,80 @@
+import { type TransportSingleOptions } from 'pino';
+export declare const loggerOptions: {
+    mixin(): {
+        trace?: {
+            id: string;
+        };
+    };
+    timestamp?: ((() => string) | boolean) | undefined;
+    enabled: boolean;
+    redact: string[] | import("pino").redactOptions;
+    level: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent" | (string & {});
+    safe?: boolean | undefined;
+    name?: string | undefined;
+    serializers?: {
+        [key: string]: import("pino").default.SerializerFn;
+    } | undefined;
+    customLevels?: {} | undefined;
+    useOnlyCustomLevels?: boolean | undefined;
+    levelComparison?: "ASC" | "DESC" | ((current: number, expected: number) => boolean) | undefined;
+    mixinMergeStrategy?: ((mergeObject: object, mixinObject: object) => object) | undefined;
+    levelVal?: number | undefined;
+    messageKey?: string | undefined;
+    errorKey?: string | undefined;
+    nestedKey?: string | undefined;
+    browser?: {
+        asObject?: boolean;
+        formatters?: {
+            level?: (label: string, number: number) => object;
+            log?: (object: Record<string, unknown>) => Record<string, unknown>;
+        };
+        write?: import("pino").default.WriteFn | ({
+            fatal?: import("pino").default.WriteFn;
+            error?: import("pino").default.WriteFn;
+            warn?: import("pino").default.WriteFn;
+            info?: import("pino").default.WriteFn;
+            debug?: import("pino").default.WriteFn;
+            trace?: import("pino").default.WriteFn;
+        } & {
+            [logLevel: string]: import("pino").default.WriteFn;
+        });
+        serialize?: boolean | string[];
+        transmit?: {
+            level?: import("pino").default.LevelOrString;
+            send: (level: import("pino").default.Level, logEvent: import("pino").default.LogEvent) => void;
+        };
+        disabled?: boolean;
+    } | undefined;
+    base?: {
+        [key: string]: any;
+    } | null | undefined;
+    formatters?: {
+        level?: (label: string, number: number) => object;
+        bindings?: (bindings: import("pino").default.Bindings) => object;
+        log?: (object: Record<string, unknown>) => Record<string, unknown>;
+    } | undefined;
+    msgPrefix?: string | undefined;
+    hooks?: {
+        logMethod?: (this: import("pino").default.Logger, args: Parameters<import("pino").default.LogFn>, method: import("pino").default.LogFn, level: number) => void;
+        streamWrite?: (s: string) => string;
+    } | undefined;
+    depthLimit?: number | undefined;
+    edgeLimit?: number | undefined;
+    onChild?: ((child: import("pino").default.Logger<never, boolean>) => void) | undefined;
+    crlf?: boolean | undefined;
+    ignorePaths: string[];
+} | {
+    mixin(): {
+        trace?: {
+            id: string;
+        };
+    };
+    transport: TransportSingleOptions;
+    enabled: boolean;
+    ignorePaths: string[];
+    redact: {
+        paths: [string, string, string];
+        remove: true;
+    };
+    level: import("pino").default.LevelWithSilent;
+};

package/.server/server/common/helpers/logging/logger.d.ts

@@ -0,0 +1 @@
+export declare function createLogger(): import("pino").Logger<never, boolean>;

package/.server/server/common/helpers/logging/request-logger.d.ts

@@ -0,0 +1,83 @@
+import hapiPino from 'hapi-pino';
+export declare const requestLogger: {
+    plugin: import("@hapi/hapi").Plugin<hapiPino.Options>;
+    options: {
+        mixin(): {
+            trace?: {
+                id: string;
+            };
+        };
+        timestamp?: ((() => string) | boolean) | undefined;
+        enabled: boolean;
+        redact: string[] | import("pino").redactOptions;
+        level: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent" | (string & {});
+        safe?: boolean | undefined;
+        name?: string | undefined;
+        serializers?: {
+            [key: string]: import("pino").default.SerializerFn;
+        } | undefined;
+        customLevels?: {} | undefined;
+        useOnlyCustomLevels?: boolean | undefined;
+        levelComparison?: "ASC" | "DESC" | ((current: number, expected: number) => boolean) | undefined;
+        mixinMergeStrategy?: ((mergeObject: object, mixinObject: object) => object) | undefined;
+        levelVal?: number | undefined;
+        messageKey?: string | undefined;
+        errorKey?: string | undefined;
+        nestedKey?: string | undefined;
+        browser?: {
+            asObject?: boolean;
+            formatters?: {
+                level?: (label: string, number: number) => object;
+                log?: (object: Record<string, unknown>) => Record<string, unknown>;
+            };
+            write?: import("pino").default.WriteFn | ({
+                fatal?: import("pino").default.WriteFn;
+                error?: import("pino").default.WriteFn;
+                warn?: import("pino").default.WriteFn;
+                info?: import("pino").default.WriteFn;
+                debug?: import("pino").default.WriteFn;
+                trace?: import("pino").default.WriteFn;
+            } & {
+                [logLevel: string]: import("pino").default.WriteFn;
+            });
+            serialize?: boolean | string[];
+            transmit?: {
+                level?: import("pino").default.LevelOrString;
+                send: (level: import("pino").default.Level, logEvent: import("pino").default.LogEvent) => void;
+            };
+            disabled?: boolean;
+        } | undefined;
+        base?: {
+            [key: string]: any;
+        } | null | undefined;
+        formatters?: {
+            level?: (label: string, number: number) => object;
+            bindings?: (bindings: import("pino").default.Bindings) => object;
+            log?: (object: Record<string, unknown>) => Record<string, unknown>;
+        } | undefined;
+        msgPrefix?: string | undefined;
+        hooks?: {
+            logMethod?: (this: import("pino").default.Logger, args: Parameters<import("pino").default.LogFn>, method: import("pino").default.LogFn, level: number) => void;
+            streamWrite?: (s: string) => string;
+        } | undefined;
+        depthLimit?: number | undefined;
+        edgeLimit?: number | undefined;
+        onChild?: ((child: import("pino").default.Logger<never, boolean>) => void) | undefined;
+        crlf?: boolean | undefined;
+        ignorePaths: string[];
+    } | {
+        mixin(): {
+            trace?: {
+                id: string;
+            };
+        };
+        transport: import("pino").TransportSingleOptions;
+        enabled: boolean;
+        ignorePaths: string[];
+        redact: {
+            paths: [string, string, string];
+            remove: true;
+        };
+        level: import("pino").default.LevelWithSilent;
+    };
+};

package/.server/server/common/helpers/logging/request-tracing.d.ts

@@ -0,0 +1,7 @@
+export namespace requestTracing {
+    export { tracing as plugin };
+    export namespace options {
+        let tracingHeader: string;
+    }
+}
+import { tracing } from '@defra/hapi-tracing';

package/.server/server/common/helpers/redis-client.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Setup Redis and provide a redis client
+ *
+ * Local development - 1 Redis instance
+ * Out in the wild - Elasticache / Redis Cluster with username and password
+ */
+export function buildRedisClient(): Redis | Cluster;
+import { Redis } from 'ioredis';
+import { Cluster } from 'ioredis';

package/.server/server/constants.d.ts

@@ -0,0 +1,3 @@
+export const PREVIEW_PATH_PREFIX: "/preview";
+export const ERROR_PREVIEW_PATH_PREFIX: "/error-preview";
+export const FORM_PREFIX: "";

package/.server/server/index.d.ts

@@ -0,0 +1,3 @@
+import hapi from '@hapi/hapi';
+import { type RouteConfig } from '~/src/server/types.js';
+export declare function createServer(routeConfig?: RouteConfig): Promise<hapi.Server<hapi.ServerApplicationState>>;

package/.server/server/plugins/crumb.d.ts

@@ -0,0 +1,4 @@
+import { type RegisterOptions } from '@hapi/crumb';
+import { type ServerRegisterPluginObject } from '@hapi/hapi';
+import { type RouteConfig } from '~/src/server/types.js';
+export declare const configureCrumbPlugin: (routeConfig?: RouteConfig) => ServerRegisterPluginObject<RegisterOptions>;

package/.server/server/plugins/engine/components/AutocompleteField.d.ts

@@ -0,0 +1,55 @@
+import { type AutocompleteFieldComponent } from '@defra/forms-model';
+import { SelectField } from '~/src/server/plugins/engine/components/SelectField.js';
+import { type FormPayload, type FormSubmissionError } from '~/src/server/plugins/engine/types.js';
+export declare class AutocompleteField extends SelectField {
+    options: AutocompleteFieldComponent['options'];
+    constructor(def: AutocompleteFieldComponent, props: ConstructorParameters<typeof SelectField>[1]);
+    getViewModel(payload: FormPayload, errors?: FormSubmissionError[]): {
+        formGroup: {
+            classes?: string;
+            attributes?: string | Record<string, string>;
+        };
+        items: import("./types.js").ListItem[];
+        label: {
+            text: string;
+        };
+        id: string;
+        name: string;
+        value: import("~/src/server/plugins/engine/types.js").FormValue;
+        type?: string;
+        hint?: {
+            id?: string;
+            text: string;
+        };
+        prefix?: import("./types.js").ComponentText;
+        suffix?: import("./types.js").ComponentText;
+        classes?: string;
+        condition?: string;
+        errors?: FormSubmissionError[];
+        errorMessage?: {
+            text: string;
+        };
+        summaryHtml?: string;
+        html?: string;
+        attributes: {
+            autocomplete?: string;
+            maxlength?: number;
+            multiple?: string;
+            accept?: string;
+            inputmode?: string;
+        };
+        content?: import("./types.js").Content | import("./types.js").Content[] | string;
+        maxlength?: number;
+        maxwords?: number;
+        rows?: number;
+        fieldset?: {
+            attributes?: string | Record<string, string>;
+            legend?: import("./types.js").Label;
+        };
+        components?: import("./types.js").ComponentViewModel[];
+        upload?: {
+            count: number;
+            summaryList: import("~/src/server/plugins/engine/types.js").SummaryList;
+        };
+    };
+}

package/.server/server/plugins/engine/components/CheckboxesField.d.ts

@@ -0,0 +1,15 @@
+import { type CheckboxesFieldComponent, type Item } from '@defra/forms-model';
+import { type ArraySchema } from 'joi';
+import { SelectionControlField } from '~/src/server/plugins/engine/components/SelectionControlField.js';
+import { type FormState, type FormStateValue, type FormSubmissionState } from '~/src/server/plugins/engine/types.js';
+export declare class CheckboxesField extends SelectionControlField {
+    options: CheckboxesFieldComponent['options'];
+    formSchema: ArraySchema<string> | ArraySchema<number>;
+    stateSchema: ArraySchema<string> | ArraySchema<number>;
+    constructor(def: CheckboxesFieldComponent, props: ConstructorParameters<typeof SelectionControlField>[1]);
+    getFormValueFromState(state: FormSubmissionState): (string | number | boolean)[] | undefined;
+    getFormValue(value?: FormStateValue | FormState): (string | number | boolean)[] | undefined;
+    getDisplayStringFromState(state: FormSubmissionState): string;
+    getContextValueFromState(state: FormSubmissionState): (string | number | boolean)[];
+    isValue(value?: FormStateValue | FormState): value is Item['value'][];
+}

package/.server/server/plugins/engine/components/ComponentBase.d.ts

@@ -0,0 +1,33 @@
+import { type ComponentDef } from '@defra/forms-model';
+import { type ArraySchema, type BooleanSchema, type DateSchema, type NumberSchema, type ObjectSchema, type StringSchema } from 'joi';
+import { type ComponentCollection } from '~/src/server/plugins/engine/components/ComponentCollection.js';
+import { type Component } from '~/src/server/plugins/engine/components/helpers.js';
+import { type ViewModel } from '~/src/server/plugins/engine/components/types.js';
+import { type FormModel } from '~/src/server/plugins/engine/models/index.js';
+import { type PageControllerClass } from '~/src/server/plugins/engine/pageControllers/helpers.js';
+export declare class ComponentBase {
+    page?: PageControllerClass;
+    parent: Component | undefined;
+    collection: ComponentCollection | undefined;
+    type: ComponentDef['type'];
+    name: ComponentDef['name'];
+    title: ComponentDef['title'];
+    schema?: Extract<ComponentDef, {
+        schema: object;
+    }>['schema'];
+    options?: Extract<ComponentDef, {
+        options: object;
+    }>['options'];
+    isFormComponent: boolean;
+    model: FormModel;
+    /** joi schemas based on a component defined in the form JSON. This validates a user's answer and is generated from {@link ComponentDef} */
+    formSchema: ComponentSchema;
+    stateSchema: ComponentSchema;
+    constructor(def: ComponentDef, props: {
+        page?: PageControllerClass;
+        parent?: Component;
+        model: FormModel;
+    });
+    get viewModel(): ViewModel;
+}
+export type ComponentSchema = ArraySchema<string> | ArraySchema<number> | ArraySchema<boolean> | ArraySchema<object> | BooleanSchema<string> | DateSchema | NumberSchema<string> | NumberSchema | ObjectSchema | StringSchema;

package/.server/server/plugins/engine/components/ComponentCollection.d.ts

@@ -0,0 +1,60 @@
+import { type ComponentDef } from '@defra/forms-model';
+import { type CustomValidator, type ErrorReportCollection, type ObjectSchema } from 'joi';
+import { type Component, type Field, type Guidance } from '~/src/server/plugins/engine/components/helpers.js';
+import { type ComponentViewModel } from '~/src/server/plugins/engine/components/types.js';
+import { type FormModel } from '~/src/server/plugins/engine/models/index.js';
+import { type PageControllerClass } from '~/src/server/plugins/engine/pageControllers/helpers.js';
+import { type FormPayload, type FormSubmissionError, type FormSubmissionState, type FormValidationResult } from '~/src/server/plugins/engine/types.js';
+import { type FormQuery } from '~/src/server/routes/types.js';
+export declare class ComponentCollection {
+    page?: PageControllerClass;
+    parent?: Component;
+    components: Component[];
+    fields: Field[];
+    guidance: Guidance[];
+    formSchema: ObjectSchema<FormPayload>;
+    stateSchema: ObjectSchema<FormSubmissionState>;
+    constructor(defs: ComponentDef[], props: {
+        page?: PageControllerClass;
+        parent?: Component;
+        model: FormModel;
+    }, schema?: {
+        /**
+         * Defines an all-or-nothing relationship between keys where if one
+         * of the peers is present, all of them are required as well
+         */
+        peers?: string[];
+        /**
+         * Defines a custom validation rule for the object schema
+         */
+        custom?: CustomValidator;
+    });
+    get keys(): string[];
+    getFormDataFromState(state: FormSubmissionState): FormPayload;
+    getFormValueFromState(state: FormSubmissionState): FormPayload;
+    getStateFromValidForm(payload: FormPayload): Partial<Record<string, import("~/src/server/plugins/engine/types.js").FormStateValue>>;
+    getContextValueFromState(state: FormSubmissionState): Partial<Record<string, import("~/src/server/plugins/engine/types.js").FormStateValue>>;
+    /**
+     * Get all errors for all fields in this collection
+     */
+    getErrors(errors?: FormSubmissionError[]): FormSubmissionError[] | undefined;
+    /**
+     * Get view errors for all fields in this collection.
+     * For most fields this means filtering to the first error in the list.
+     * Composite fields like UKAddress can choose to return more than one error.
+     */
+    getViewErrors(errors?: FormSubmissionError[]): FormSubmissionError[] | undefined;
+    getViewModel(payload: FormPayload, errors?: FormSubmissionError[], query?: FormQuery): ComponentViewModel[];
+    /**
+     * Validate form payload
+     */
+    validate(value?: FormPayload): FormValidationResult<FormPayload>;
+    /**
+     * Helper to get errors from all fields
+     */
+    private getFieldErrors;
+}
+/**
+ * Check for field local state
+ */
+export declare function isErrorContext(value?: unknown): value is ErrorReportCollection['local'];

package/.server/server/plugins/engine/components/DatePartsField.d.ts

@@ -0,0 +1,76 @@
+import { type DatePartsFieldComponent } from '@defra/forms-model';
+import { type CustomValidator, type ObjectSchema } from 'joi';
+import { ComponentCollection } from '~/src/server/plugins/engine/components/ComponentCollection.js';
+import { FormComponent } from '~/src/server/plugins/engine/components/FormComponent.js';
+import { type DateInputItem } from '~/src/server/plugins/engine/components/types.js';
+import { type ErrorMessageTemplateList, type FormPayload, type FormState, type FormStateValue, type FormSubmissionError, type FormSubmissionState } from '~/src/server/plugins/engine/types.js';
+export declare class DatePartsField extends FormComponent {
+    options: DatePartsFieldComponent['options'];
+    formSchema: ObjectSchema<FormPayload>;
+    stateSchema: ObjectSchema<FormState>;
+    collection: ComponentCollection;
+    constructor(def: DatePartsFieldComponent, props: ConstructorParameters<typeof FormComponent>[1]);
+    getFormValueFromState(state: FormSubmissionState): DatePartsState | undefined;
+    getDisplayStringFromState(state: FormSubmissionState): string;
+    getContextValueFromState(state: FormSubmissionState): string | null;
+    getViewModel(payload: FormPayload, errors?: FormSubmissionError[]): {
+        fieldset: {
+            attributes?: string | Record<string, string>;
+            legend?: import("~/src/server/plugins/engine/components/types.js").Label;
+        };
+        items: DateInputItem[];
+        label: {
+            text: string;
+        };
+        id: string;
+        name: string;
+        value: import("~/src/server/plugins/engine/types.js").FormValue;
+        type?: string;
+        hint?: {
+            id?: string;
+            text: string;
+        };
+        prefix?: import("~/src/server/plugins/engine/components/types.js").ComponentText;
+        suffix?: import("~/src/server/plugins/engine/components/types.js").ComponentText;
+        classes?: string;
+        condition?: string;
+        errors?: FormSubmissionError[];
+        errorMessage?: {
+            text: string;
+        };
+        summaryHtml?: string;
+        html?: string;
+        attributes: {
+            autocomplete?: string;
+            maxlength?: number;
+            multiple?: string;
+            accept?: string;
+            inputmode?: string;
+        };
+        content?: import("~/src/server/plugins/engine/components/types.js").Content | import("~/src/server/plugins/engine/components/types.js").Content[] | string;
+        maxlength?: number;
+        maxwords?: number;
+        rows?: number;
+        formGroup?: {
+            classes?: string;
+            attributes?: string | Record<string, string>;
+        };
+        components?: import("~/src/server/plugins/engine/components/types.js").ComponentViewModel[];
+        upload?: {
+            count: number;
+            summaryList: import("~/src/server/plugins/engine/types.js").SummaryList;
+        };
+    };
+    isState(value?: FormStateValue | FormState): value is DatePartsState;
+    /**
+     * For error preview page that shows all possible errors on a component
+     */
+    getAllPossibleErrors(): ErrorMessageTemplateList;
+    static isDateParts(value?: FormStateValue | FormState): value is DatePartsState;
+}
+export interface DatePartsState extends Record<string, number> {
+    day: number;
+    month: number;
+    year: number;
+}
+export declare function getValidatorDate(component: DatePartsField): CustomValidator;

package/.server/server/plugins/engine/components/Details.d.ts

@@ -0,0 +1,53 @@
+import { type DetailsComponent } from '@defra/forms-model';
+import { ComponentBase } from '~/src/server/plugins/engine/components/ComponentBase.js';
+export declare class Details extends ComponentBase {
+    options: DetailsComponent['options'];
+    content: DetailsComponent['content'];
+    constructor(def: DetailsComponent, props: ConstructorParameters<typeof ComponentBase>[1]);
+    getViewModel(): {
+        html: string;
+        summaryHtml: string;
+        label?: import("./types.js").Label;
+        type?: string;
+        id?: string;
+        name?: string;
+        value?: import("../types.js").FormValue;
+        hint?: {
+            id?: string;
+            text: string;
+        };
+        prefix?: import("./types.js").ComponentText;
+        suffix?: import("./types.js").ComponentText;
+        classes?: string;
+        condition?: string;
+        errors?: import("../types.js").FormSubmissionError[];
+        errorMessage?: {
+            text: string;
+        };
+        attributes: {
+            autocomplete?: string;
+            maxlength?: number;
+            multiple?: string;
+            accept?: string;
+            inputmode?: string;
+        };
+        content?: import("./types.js").Content | import("./types.js").Content[] | string;
+        maxlength?: number;
+        maxwords?: number;
+        rows?: number;
+        items?: import("./types.js").ListItem[] | import("./types.js").DateInputItem[];
+        fieldset?: {
+            attributes?: string | Record<string, string>;
+            legend?: import("./types.js").Label;
+        };
+        formGroup?: {
+            classes?: string;
+            attributes?: string | Record<string, string>;
+        };
+        components?: import("./types.js").ComponentViewModel[];
+        upload?: {
+            count: number;
+            summaryList: import("../types.js").SummaryList;
+        };
+    };
+}

package/.server/server/plugins/engine/components/EmailAddressField.d.ts

@@ -0,0 +1,59 @@
+import { type EmailAddressFieldComponent } from '@defra/forms-model';
+import { FormComponent } from '~/src/server/plugins/engine/components/FormComponent.js';
+import { type ErrorMessageTemplateList, type FormPayload, type FormSubmissionError } from '~/src/server/plugins/engine/types.js';
+export declare class EmailAddressField extends FormComponent {
+    options: EmailAddressFieldComponent['options'];
+    constructor(def: EmailAddressFieldComponent, props: ConstructorParameters<typeof FormComponent>[1]);
+    getViewModel(payload: FormPayload, errors?: FormSubmissionError[]): {
+        type: string;
+        label: {
+            text: string;
+        };
+        id: string;
+        name: string;
+        value: import("~/src/server/plugins/engine/types.js").FormValue;
+        hint?: {
+            id?: string;
+            text: string;
+        };
+        prefix?: import("./types.js").ComponentText;
+        suffix?: import("./types.js").ComponentText;
+        classes?: string;
+        condition?: string;
+        errors?: FormSubmissionError[];
+        errorMessage?: {
+            text: string;
+        };
+        summaryHtml?: string;
+        html?: string;
+        attributes: {
+            autocomplete?: string;
+            maxlength?: number;
+            multiple?: string;
+            accept?: string;
+            inputmode?: string;
+        };
+        content?: import("./types.js").Content | import("./types.js").Content[] | string;
+        maxlength?: number;
+        maxwords?: number;
+        rows?: number;
+        items?: import("./types.js").ListItem[] | import("./types.js").DateInputItem[];
+        fieldset?: {
+            attributes?: string | Record<string, string>;
+            legend?: import("./types.js").Label;
+        };
+        formGroup?: {
+            classes?: string;
+            attributes?: string | Record<string, string>;
+        };
+        components?: import("./types.js").ComponentViewModel[];
+        upload?: {
+            count: number;
+            summaryList: import("~/src/server/plugins/engine/types.js").SummaryList;
+        };
+    };
+    /**
+     * For error preview page that shows all possible errors on a component
+     */
+    getAllPossibleErrors(): ErrorMessageTemplateList;
+}