@uides/stepwise 2.0.0-a402a664 → 2.0.0-a64dc016

package/schemas/step.js

@@ -0,0 +1,115 @@
+import { any, array, boolean as external_valibot_boolean, nullish, number, object, picklist, pipe, record, strictObject, string } from "valibot";
+import { ActionsSchema } from "./action.js";
+import { ComponentLayoutSchema, DisplayLangSchema, DisplayModeSchema, validateField } from "./common.js";
+import { FieldsSchema } from "./field/index.js";
+import { FieldsetsSchema } from "./fieldset/index.js";
+const ManifestAttachmentSchema = strictObject({
+    field_name: string(),
+    retrieval_scope: nullish(string()),
+    'manifest-position': picklist([
+        'no',
+        'begin',
+        'end'
+    ]),
+    'attachment-handler': nullish(string())
+});
+const StepDisplayContentSchema = strictObject({
+    title: nullish(string()),
+    captionLeft: nullish(string()),
+    serviceName: nullish(string()),
+    serviceURL: nullish(string()),
+    serviceLogo: nullish(string()),
+    serviceLogoURL: nullish(string()),
+    footerContent: nullish(string()),
+    footerLogo: nullish(string()),
+    footerTop: nullish(external_valibot_boolean()),
+    termsTitle: nullish(string()),
+    termsURL: nullish(string()),
+    fontName: nullish(string()),
+    'page-numbering': nullish(external_valibot_boolean()),
+    'signature-position': nullish(array(number())),
+    'signature-page': nullish(picklist([
+        'first',
+        'last'
+    ])),
+    'state-label': nullish(record(picklist([
+        'editing',
+        'issued'
+    ]), string())),
+    'sidebar-state-label': nullish(string()),
+    'sidebar-refcode-label': nullish(string()),
+    'sidebar-template-label': nullish(string()),
+    'sidebar-issuedate-label': nullish(string()),
+    'success-message': nullish(string()),
+    'success-code-message': nullish(string()),
+    'as-manifest-for-attachment': nullish(ManifestAttachmentSchema),
+    layout: nullish(ComponentLayoutSchema),
+    pagesize: nullish(string())
+});
+const StepDisplaySchema = record(DisplayModeSchema, record(DisplayLangSchema, StepDisplayContentSchema));
+const PossibleNextStepsSchema = strictObject({
+    documentation: strictObject({
+        label: string()
+    })
+});
+const StepSchema = pipe(strictObject({
+    actions: nullish(ActionsSchema),
+    'action-order': string(),
+    fields: nullish(FieldsSchema),
+    fieldsets: nullish(FieldsetsSchema),
+    'fieldset-order': string(),
+    possible_next_steps: nullish(record(string(), PossibleNextStepsSchema)),
+    'field-compute-order': nullish(string()),
+    next_step: nullish(string()),
+    pre_access_hook: nullish(string()),
+    decide_next_step: nullish(string()),
+    display: StepDisplaySchema,
+    validator: nullish(string()),
+    'is-final-view': nullish(external_valibot_boolean()),
+    validation_dynamic_info: nullish(string()),
+    'has-display-fields': nullish(external_valibot_boolean()),
+    targets: nullish(array(record(string(), any()))),
+    'post-step-claims': nullish(array(string()))
+}), validateField('fieldsets', (fieldsets, step)=>{
+    if (!fieldsets || !step.fields) return true;
+    const fieldsSpec = step.fields;
+    for (const fieldset of Object.values(fieldsets))if (!validateOrderOnSet(fieldset['field-order'], fieldsSpec)) return false;
+    return true;
+}), validateField('fieldset-order', (fieldsetOrder, step)=>{
+    if (!fieldsetOrder || !step.fieldsets) return true;
+    return validateOrderOnSet(fieldsetOrder, step.fieldsets);
+}), validateField('action-order', (actionOrder, step)=>{
+    if (!actionOrder || !step.actions) return true;
+    return validateOrderOnSet(actionOrder, step.actions);
+}), validateField('decide_next_step', (decideNextStep, step)=>{
+    if (!decideNextStep) return true;
+    const possibleNextSteps = Object.keys(step.possible_next_steps || {});
+    if (!possibleNextSteps.length) return false;
+    return true;
+}), validateField('fields', (fields, step)=>{
+    const actions = step.actions;
+    const actionOrder = step['action-order'];
+    if (!actionOrder.split(' ').includes('update')) return true;
+    if (actions && actions['update'] && 'component-params' in actions['update'] && actions['update']['component-params'] && 'ensure-no-input' in actions['update']['component-params'] && actions['update']['component-params']['ensure-no-input']) {
+        for (const field of Object.values(fields || {}))if ('noinput' !== field['user-input-mode'] && 'display' !== field['user-input-mode']) return false;
+    }
+    return true;
+}), validateField('fields', (fields)=>{
+    for (const field of Object.values(fields || {}))if (('required' === field['user-input-mode'] || 'optional' === field['user-input-mode']) && !field.display) return false;
+    return true;
+}));
+function validateOrderOnSet(orderString, setSpec) {
+    if (!orderString) return true;
+    const existingElems = Object.keys(setSpec);
+    for (const elem of orderString.split(' '))if (!existingElems.includes(elem)) return false;
+    return true;
+}
+const StepsSchema = record(string(), StepSchema);
+const StepsSpecSchema = object({
+    'steps-order': string(),
+    collectable: nullish(external_valibot_boolean()),
+    sign: nullish(external_valibot_boolean()),
+    steps: StepsSchema,
+    'intro-step': nullish(StepSchema)
+});
+export { StepDisplayContentSchema, StepSchema, StepsSpecSchema };

package/schemas/template/index.d.ts

@@ -0,0 +1,2 @@
+export * from './template-source.js';
+export * from './template.js';

package/schemas/template/index.js

@@ -0,0 +1,2 @@
+export * from "./template-source.js";
+export * from "./template.js";

package/schemas/template/template-base.d.ts

@@ -0,0 +1,53 @@
+import * as v from 'valibot';
+import { StepsSpecSchemaType } from '../step.js';
+/**
+ * Describes a template
+ *
+ * A template is a set of steps that the user must complete in order to complete a process
+ * in the system, whether that is the issuance of a document or the entry of a request.
+ */
+export declare const TemplateBaseSchema: v.StrictObjectSchema<{
+    /**
+     * Template's creation date
+     */
+    readonly created_at: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    /** Brief summary of template */
+    readonly description: v.StringSchema<undefined>;
+    readonly id: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+    /**
+     * Defines the fields that are used to index documents
+     *
+     * A list of fields of the document, that are used to index multiple documents upon their
+     * presentation to the user's gate interface.
+     */
+    readonly index_by_fields: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Whether the template is officially published or not.
+     *
+     * If true then template is officially published and functional.
+     * Otherwise it is considered a draft and the documents it produces are not valid.
+     * @default true
+     */
+    readonly is_official: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+    /**
+     * Codename of the gate that owns the template
+     *
+     * An entity's gate can be the owner of a template. If not specified, the template is considered
+     * to be owned by the "System".
+     */
+    readonly owner: v.StringSchema<undefined>;
+    /** The template's unique identifier */
+    readonly refname: v.StringSchema<undefined>;
+    /**
+     * List of templates with which replies to the document can be issued.
+     */
+    readonly reply_templates: v.NullishSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /** Brief title of template */
+    readonly shortname: v.StringSchema<undefined>;
+    /**
+     * Specification of the steps of the template.
+     */
+    readonly steps_spec: v.NullishSchema<StepsSpecSchemaType, undefined>;
+}, undefined>;
+export type TemplateBase = v.InferOutput<typeof TemplateBaseSchema>;
+export default TemplateBase;

package/schemas/template/template-base.js

@@ -0,0 +1,15 @@
+import { array, boolean as external_valibot_boolean, nullish, number, strictObject, string } from "valibot";
+import { StepsSpecSchema } from "../step.js";
+const TemplateBaseSchema = strictObject({
+    created_at: nullish(string()),
+    description: string(),
+    id: nullish(number()),
+    index_by_fields: nullish(string()),
+    is_official: nullish(external_valibot_boolean()),
+    owner: string(),
+    refname: string(),
+    reply_templates: nullish(array(string())),
+    shortname: string(),
+    steps_spec: nullish(StepsSpecSchema)
+});
+export { TemplateBaseSchema };

package/schemas/template/template-source.d.ts

@@ -0,0 +1,50 @@
+import * as v from 'valibot';
+/**
+ * Template model used in the backend.
+ *
+ * This describes the template as it is stored in the database. Some of the fields present in the
+ * backend model are not used in the frontend type.
+ *
+ * @see {@link TemplateBase} for the definition of a template.
+ */
+export declare const TemplateSourceSchema: v.StrictObjectSchema<{
+    /**
+     * Action to execute when the document is issued.
+     */
+    readonly action_on_issue: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly case_prefixes: v.NullishSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * Claims that are not checked for in the user's session
+     */
+    readonly exempted_claims: v.NullishSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * Extra claims to check for in the user's session.
+     *
+     * When creating a new declaration that includes the template, the application checks
+     * that the session contains all the claims specified in this field.
+     */
+    readonly extra_required_claims: v.NullishSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly posting_whitelist: v.NullishSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     *  Whether a case number is assigned on instantiation of the template.
+     *  @default false
+     */
+    readonly requires_case: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly validation_context: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Defines the access policy of th document in the validation phase
+     */
+    readonly validation_policy: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly created_at: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly description: v.StringSchema<undefined>;
+    readonly id: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+    readonly index_by_fields: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly is_official: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly owner: v.StringSchema<undefined>;
+    readonly refname: v.StringSchema<undefined>;
+    readonly reply_templates: v.NullishSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly shortname: v.StringSchema<undefined>;
+    readonly steps_spec: v.NullishSchema<import("../index.js").StepsSpecSchemaType, undefined>;
+}, undefined>;
+export type TemplateSource = v.InferOutput<typeof TemplateSourceSchema>;
+export default TemplateSource;

package/schemas/template/template-source.js

@@ -0,0 +1,14 @@
+import { array, boolean as external_valibot_boolean, nullish, strictObject, string } from "valibot";
+import { TemplateBaseSchema } from "./template-base.js";
+const TemplateSourceSchema = strictObject({
+    ...TemplateBaseSchema.entries,
+    action_on_issue: nullish(string()),
+    case_prefixes: nullish(array(string())),
+    exempted_claims: nullish(array(string())),
+    extra_required_claims: nullish(array(string())),
+    posting_whitelist: nullish(array(string())),
+    requires_case: nullish(external_valibot_boolean()),
+    validation_context: nullish(string()),
+    validation_policy: nullish(string())
+});
+export { TemplateSourceSchema };

package/schemas/template/template.d.ts

@@ -0,0 +1,54 @@
+import * as v from 'valibot';
+/**
+ * Template type used in the frontend.
+ *
+ * This describes the template as it is returned by the API to the frontend.
+ * Some of the fields present in the backend model are not used in the frontend type.
+ *
+ * @see {@link TemplateBase} for the definition of a template.
+ */
+export declare const TemplateSchema: v.StrictObjectSchema<{
+    /**
+     * Whether the template is enabled or not.
+     */
+    readonly enabled: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly template_type: v.StrictObjectSchema<{
+        /** @default 'application' */
+        readonly refname: v.StringSchema<undefined>;
+        /** @default [] */
+        readonly fields: v.ArraySchema<v.AnySchema, undefined>;
+    }, undefined>;
+    readonly consent_method: v.PicklistSchema<["login", "otp", "gov_wallet_or_otp"], undefined>;
+    /**
+     * Recipient's business title
+     * @deprecated
+     */
+    readonly recipient_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Claims that the application checks for in the user's session.
+     *
+     * @default ['mobile_certified_login','is_citizen_user','govgr_login']
+     */
+    readonly required_claims: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Codename of the gate that owns the template
+     *
+     * An entity's gate can be the owner of a template. If not specified, the template is considered
+     * to be owned by the "System".
+     */
+    readonly owner: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly login_endpoint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly fields: v.NullishSchema<v.ArraySchema<v.AnySchema, undefined>, undefined>;
+    readonly 'ui:legacy_renderer': v.BooleanSchema<undefined>;
+    readonly created_at: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly description: v.StringSchema<undefined>;
+    readonly id: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+    readonly index_by_fields: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly is_official: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly refname: v.StringSchema<undefined>;
+    readonly reply_templates: v.NullishSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly shortname: v.StringSchema<undefined>;
+    readonly steps_spec: v.NullishSchema<import("../index.js").StepsSpecSchemaType, undefined>;
+}, undefined>;
+export type Template = v.InferOutput<typeof TemplateSchema>;
+export default Template;

package/schemas/template/template.js

@@ -0,0 +1,22 @@
+import { any, array, boolean as external_valibot_boolean, nullish, picklist, strictObject, string } from "valibot";
+import { TemplateBaseSchema } from "./template-base.js";
+const TemplateSchema = strictObject({
+    ...TemplateBaseSchema.entries,
+    enabled: nullish(external_valibot_boolean()),
+    template_type: strictObject({
+        refname: string(),
+        fields: array(any())
+    }),
+    consent_method: picklist([
+        'login',
+        'otp',
+        'gov_wallet_or_otp'
+    ]),
+    recipient_hint: nullish(string()),
+    required_claims: array(string()),
+    owner: nullish(string()),
+    login_endpoint: nullish(string()),
+    fields: nullish(array(any())),
+    'ui:legacy_renderer': external_valibot_boolean()
+});
+export { TemplateSchema };

package/schemas/validation-context/enums.d.ts

@@ -0,0 +1,10 @@
+import * as v from 'valibot';
+/**
+ * Validation field component type.
+ *
+ * @value 'validate-document-string' Validate document string.
+ * @value 'validate-document-qrcode' Validate document QR code.
+ * @value 'paragraph' Paragraph.
+ */
+export declare const ValidationFieldComponentSchema: v.PicklistSchema<["validate-document-string", "validate-document-qrcode", "paragraph"], undefined>;
+export type ValidationFieldComponent = v.InferOutput<typeof ValidationFieldComponentSchema>;

package/schemas/validation-context/enums.js

@@ -0,0 +1,7 @@
+import { picklist } from "valibot";
+const ValidationFieldComponentSchema = picklist([
+    'validate-document-string',
+    'validate-document-qrcode',
+    'paragraph'
+]);
+export { ValidationFieldComponentSchema };

package/schemas/validation-context/index.d.ts

@@ -0,0 +1,2 @@
+export * from './validation-context.js';
+export * from './enums.js';

package/schemas/validation-context/index.js

@@ -0,0 +1,2 @@
+export * from "./validation-context.js";
+export * from "./enums.js";

package/schemas/validation-context/validation-context.d.ts

@@ -0,0 +1,131 @@
+import * as v from 'valibot';
+export declare const ValidationComponentParamsSchema: v.StrictObjectSchema<{
+    readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly label: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly text: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly helptext: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly 'action-label': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly 'action-cancel-label': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly 'error-messages': v.NullishSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+    readonly note: v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>;
+}, undefined>;
+export declare const ValidationFieldSchema: v.StrictObjectSchema<{
+    readonly display: v.RecordSchema<v.PicklistSchema<["default", "web", "pdf"], undefined>, v.RecordSchema<v.PicklistSchema<["default", "el", "en", "fr"], undefined>, v.StrictObjectSchema<{
+        readonly component: v.NullishSchema<v.PicklistSchema<["validate-document-string", "validate-document-qrcode", "paragraph"], undefined>, undefined>;
+        readonly 'component-params': v.NullishSchema<v.UnionSchema<[v.StrictObjectSchema<{
+            readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly label: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly text: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly helptext: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly 'action-label': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly 'action-cancel-label': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly 'error-messages': v.NullishSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+            readonly note: v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>;
+        }, undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly grid: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly xs: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly sm: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly lg: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly xl: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly 'user-input-mode': v.PicklistSchema<["required", "optional", "noinput", "display"], undefined>;
+}, undefined>;
+export declare const ValidationFieldsetSchema: v.StrictObjectSchema<{
+    readonly display: v.RecordSchema<v.PicklistSchema<["default", "web", "pdf"], undefined>, v.RecordSchema<v.PicklistSchema<["default", "el", "en", "fr"], undefined>, v.StrictObjectSchema<{
+        readonly component: v.NullishSchema<v.LiteralSchema<"form", undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly grid: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly xs: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly sm: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly lg: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly xl: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly 'field-order': v.StringSchema<undefined>;
+}, undefined>;
+export declare const ValidationContextDisplaySchema: v.StrictObjectSchema<{
+    readonly serviceName: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly serviceURL: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly backlink: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+        readonly grid: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly xs: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly sm: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly lg: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly xl: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly i18n: v.NullishSchema<v.StrictObjectSchema<{
+        readonly languages: v.RecordSchema<v.PicklistSchema<["default", "el", "en", "fr"], undefined>, v.StrictObjectSchema<{
+            readonly label: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly 'language-order': v.StringSchema<undefined>;
+        readonly 'default-language': v.PicklistSchema<["default", "el", "en", "fr"], undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const ValidationContextSchema: v.StrictObjectSchema<{
+    readonly display: v.RecordSchema<v.PicklistSchema<["default", "web", "pdf"], undefined>, v.RecordSchema<v.PicklistSchema<["default", "el", "en", "fr"], undefined>, v.StrictObjectSchema<{
+        readonly serviceName: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly serviceURL: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly backlink: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly grid: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly xs: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly sm: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly lg: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            readonly xl: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly i18n: v.NullishSchema<v.StrictObjectSchema<{
+            readonly languages: v.RecordSchema<v.PicklistSchema<["default", "el", "en", "fr"], undefined>, v.StrictObjectSchema<{
+                readonly label: v.StringSchema<undefined>;
+            }, undefined>, undefined>;
+            readonly 'language-order': v.StringSchema<undefined>;
+            readonly 'default-language': v.PicklistSchema<["default", "el", "en", "fr"], undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly fields: v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
+        readonly display: v.RecordSchema<v.PicklistSchema<["default", "web", "pdf"], undefined>, v.RecordSchema<v.PicklistSchema<["default", "el", "en", "fr"], undefined>, v.StrictObjectSchema<{
+            readonly component: v.NullishSchema<v.PicklistSchema<["validate-document-string", "validate-document-qrcode", "paragraph"], undefined>, undefined>;
+            readonly 'component-params': v.NullishSchema<v.UnionSchema<[v.StrictObjectSchema<{
+                readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly label: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly text: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly helptext: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly 'action-label': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly 'action-cancel-label': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly 'error-messages': v.NullishSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+                readonly note: v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>;
+            }, undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, undefined>;
+            readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+                readonly grid: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly xs: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly sm: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly lg: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly xl: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>, undefined>, undefined>;
+        readonly 'user-input-mode': v.PicklistSchema<["required", "optional", "noinput", "display"], undefined>;
+    }, undefined>, undefined>;
+    readonly fieldsets: v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
+        readonly display: v.RecordSchema<v.PicklistSchema<["default", "web", "pdf"], undefined>, v.RecordSchema<v.PicklistSchema<["default", "el", "en", "fr"], undefined>, v.StrictObjectSchema<{
+            readonly component: v.NullishSchema<v.LiteralSchema<"form", undefined>, undefined>;
+            readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+                readonly grid: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+                readonly xs: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly sm: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly lg: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+                readonly xl: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>, undefined>, undefined>;
+        readonly 'field-order': v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly 'action-order': v.StringSchema<undefined>;
+    readonly 'fieldset-order': v.StringSchema<undefined>;
+}, undefined>;

package/schemas/validation-context/validation-context.js

@@ -0,0 +1,55 @@
+import { any, boolean as external_valibot_boolean, literal, nullish, record, strictObject, string, union } from "valibot";
+import { ComponentLayoutSchema, DisplayLangSchema, DisplayModeSchema, UserInputModeSchema } from "../common.js";
+import { ValidationFieldComponentSchema } from "./enums.js";
+const ValidationComponentParamsSchema = strictObject({
+    title: nullish(string()),
+    label: nullish(string()),
+    text: nullish(string()),
+    helptext: nullish(string()),
+    'action-label': nullish(string()),
+    'action-cancel-label': nullish(string()),
+    'error-messages': nullish(record(string(), string())),
+    note: record(string(), any())
+});
+const ValidationFieldDisplaySchema = strictObject({
+    component: nullish(ValidationFieldComponentSchema),
+    'component-params': nullish(union([
+        ValidationComponentParamsSchema,
+        record(string(), any())
+    ])),
+    layout: nullish(ComponentLayoutSchema)
+});
+const ValidationFieldSchema = strictObject({
+    display: record(DisplayModeSchema, record(DisplayLangSchema, ValidationFieldDisplaySchema)),
+    'user-input-mode': UserInputModeSchema
+});
+const ValidationFieldsetDisplaySchema = strictObject({
+    component: nullish(literal('form')),
+    layout: nullish(ComponentLayoutSchema)
+});
+const ValidationFieldsetSchema = strictObject({
+    display: record(DisplayModeSchema, record(DisplayLangSchema, ValidationFieldsetDisplaySchema)),
+    'field-order': string()
+});
+const I18nSchema = strictObject({
+    languages: record(DisplayLangSchema, strictObject({
+        label: string()
+    })),
+    'language-order': string(),
+    'default-language': DisplayLangSchema
+});
+const ValidationContextDisplaySchema = strictObject({
+    serviceName: nullish(string()),
+    serviceURL: nullish(string()),
+    backlink: nullish(external_valibot_boolean()),
+    layout: nullish(ComponentLayoutSchema),
+    i18n: nullish(I18nSchema)
+});
+const ValidationContextSchema = strictObject({
+    display: record(DisplayModeSchema, record(DisplayLangSchema, ValidationContextDisplaySchema)),
+    fields: record(string(), ValidationFieldSchema),
+    fieldsets: record(string(), ValidationFieldsetSchema),
+    'action-order': string(),
+    'fieldset-order': string()
+});
+export { ValidationComponentParamsSchema, ValidationContextDisplaySchema, ValidationContextSchema, ValidationFieldSchema, ValidationFieldsetSchema };

package/src/schemas/action.ts

@@ -110,6 +110,15 @@ export const ResendOtpSchema = v.strictObject({
 });
 export type ResendOtp = v.InferOutput<typeof ResendOtpSchema>;
 
+export const ResendEmailOtpSchema = v.strictObject({
+  display: createActionDisplay(
+    v.strictObject({
+      component: v.literal('document-resend-email-otp'),
+    })
+  ),
+});
+export type ResendEmailOtp = v.InferOutput<typeof ResendEmailOtpSchema>;
+
 export const CancelSchema = v.strictObject({
   display: createActionDisplay(
     v.strictObject({
@@ -145,6 +154,11 @@ export const CreateSchema = v.strictObject({
       component: v.literal('document-create'),
     })
   ),
+  'component-params': v.nullish(
+    v.strictObject({
+      interactive: v.nullish(v.boolean()),
+    })
+  ),
 });
 export type Create = v.InferOutput<typeof CreateSchema>;
 
@@ -305,6 +319,7 @@ export const ActionSchema = v.variant('display', [
   TemporarySaveSchema,
   PdfSchema,
   ResendOtpSchema,
+  ResendEmailOtpSchema,
   CancelSchema,
   UpdateSchema,
   CreateSchema,

package/src/schemas/common.ts

@@ -14,6 +14,22 @@ export const FontSchema = v.picklist([
   'OpenSans-Light',
 ]);
 
+/**
+ * Describes how user input is handled by the field.
+ *
+ * @value 'required' Required user input. No empty value allowed.
+ * @value 'optional' Optional user input. Field can be left empty.
+ * @value 'noinput' No user input allowed, like 'display'.
+ * @value 'display' Display only the value of the field, like 'noinput'.
+ */
+export const UserInputModeSchema = v.picklist([
+  'required',
+  'optional',
+  'noinput',
+  'display',
+]);
+export type UserInputMode = v.InferOutput<typeof UserInputModeSchema>;
+
 export const ComponentLayoutSchema = v.strictObject({
   grid: v.nullish(v.boolean()),
   xs: v.nullish(v.string()),

package/src/schemas/field/afm/index.ts

@@ -7,29 +7,13 @@ const AfmDisplaySchema = createFieldDisplay(
   })
 );
 
-const AfmAttributeSchema = v.nullish(
-  v.picklist([
-    'afm',
-    'confirm_signatories:afm',
-    'find_idiotiko_sym:signatories_afm',
-    'find_idiotiko_sym_service:statements/citizen_afm',
-    'find_idiotiko_sym_service:statements/service_afm',
-    'find_onomatodosia:signatory_1_afm',
-    'find_onomatodosia:signatory_2_afm',
-    'find_yde:signatory_1_afm',
-    'find_yde:signatory_2_afm',
-    'find_yde:signatory_3_afm',
-    'gsis_confirmed_person:afm',
-    'gsis_registry:afm',
-  ])
-);
-
 const AfmSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required', 'display']),
-  attribute: AfmAttributeSchema,
+  attribute: v.nullish(v.string()),
   datatype: v.nullish(v.literal('afm')),
   display: AfmDisplaySchema,
   'default-value': v.nullish(v.string()),
+  sources: v.nullish(v.string()),
 });
 export type AfmType = v.InferOutput<typeof AfmSchema>;
 export type AfmSchemaType = v.GenericSchema<AfmType>;