@uides/stepwise 2.0.0-a402a664 → 2.0.0-a64dc016

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

@@ -0,0 +1,52 @@
+import * as v from 'valibot';
+declare const AfmSchema: v.StrictObjectSchema<{
+    readonly 'user-input-mode': v.PicklistSchema<["noinput", "optional", "required", "display"], undefined>;
+    readonly attribute: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly datatype: v.NullishSchema<v.LiteralSchema<"afm", undefined>, undefined>;
+    readonly display: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, v.RawCheckAction<import("../common.js").DisplayType<v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"afm", undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"afm", undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"afm", undefined>;
+    }, undefined>>>]>;
+    readonly 'default-value': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly sources: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type AfmType = v.InferOutput<typeof AfmSchema>;
+export type AfmSchemaType = v.GenericSchema<AfmType>;
+declare const _default: AfmSchemaType;
+export default _default;

package/schemas/field/afm/index.js

@@ -0,0 +1,20 @@
+import { literal, nullish, picklist, strictObject, string } from "valibot";
+import { createFieldDisplay } from "../common.js";
+const AfmDisplaySchema = createFieldDisplay(strictObject({
+    component: literal('afm')
+}));
+const AfmSchema = strictObject({
+    'user-input-mode': picklist([
+        'noinput',
+        'optional',
+        'required',
+        'display'
+    ]),
+    attribute: nullish(string()),
+    datatype: nullish(literal('afm')),
+    display: AfmDisplaySchema,
+    'default-value': nullish(string()),
+    sources: nullish(string())
+});
+const afm = AfmSchema;
+export { afm as default };

package/schemas/field/amka/index.d.ts

@@ -0,0 +1,60 @@
+import * as v from 'valibot';
+declare const AmkaSchema: v.StrictObjectSchema<{
+    readonly 'user-input-mode': v.PicklistSchema<["noinput", "optional", "required"], undefined>;
+    readonly attribute: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly display: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, v.RawCheckAction<import("../common.js").DisplayType<v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"amka", undefined>;
+        readonly 'component-params': v.NullishSchema<v.StrictObjectSchema<{
+            readonly textColor: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"amka", undefined>;
+        readonly 'component-params': v.NullishSchema<v.StrictObjectSchema<{
+            readonly textColor: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"amka", undefined>;
+        readonly 'component-params': v.NullishSchema<v.StrictObjectSchema<{
+            readonly textColor: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>>>]>;
+    readonly datatype: v.NullishSchema<v.LiteralSchema<"amka", undefined>, undefined>;
+    readonly 'default-value': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type AmkaType = v.InferOutput<typeof AmkaSchema>;
+export type AmkaSchemaType = v.GenericSchema<AmkaType>;
+declare const _default: AmkaSchemaType;
+export default _default;

package/schemas/field/amka/index.js

@@ -0,0 +1,21 @@
+import { literal, nullish, picklist, strictObject, string } from "valibot";
+import { createFieldDisplay } from "../common.js";
+const AmkaDisplaySchema = createFieldDisplay(strictObject({
+    component: literal('amka'),
+    'component-params': nullish(strictObject({
+        textColor: nullish(string())
+    }))
+}));
+const AmkaSchema = strictObject({
+    'user-input-mode': picklist([
+        'noinput',
+        'optional',
+        'required'
+    ]),
+    attribute: nullish(string()),
+    display: AmkaDisplaySchema,
+    datatype: nullish(literal('amka')),
+    'default-value': nullish(string())
+});
+const amka = AmkaSchema;
+export { amka as default };

package/schemas/field/attachment/index.d.ts

@@ -0,0 +1,68 @@
+import * as v from 'valibot';
+declare const AttachmentSchema: v.StrictObjectSchema<{
+    readonly 'user-input-mode': v.PicklistSchema<["noinput", "optional", "required", "display"], undefined>;
+    readonly datatype: v.NullishSchema<v.LiteralSchema<"attachment", undefined>, undefined>;
+    readonly attribute: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly display: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, v.RawCheckAction<import("../common.js").DisplayType<v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"attachment", undefined>;
+        readonly 'component-params': v.NullishSchema<v.StrictObjectSchema<{
+            readonly multiplicity: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+            readonly filetype: v.NullishSchema<v.PicklistSchema<["pdf", "pdf-for-mark"], undefined>, undefined>;
+            readonly 'file-max-size': v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"attachment", undefined>;
+        readonly 'component-params': v.NullishSchema<v.StrictObjectSchema<{
+            readonly multiplicity: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+            readonly filetype: v.NullishSchema<v.PicklistSchema<["pdf", "pdf-for-mark"], undefined>, undefined>;
+            readonly 'file-max-size': v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"attachment", undefined>;
+        readonly 'component-params': v.NullishSchema<v.StrictObjectSchema<{
+            readonly multiplicity: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+            readonly filetype: v.NullishSchema<v.PicklistSchema<["pdf", "pdf-for-mark"], undefined>, undefined>;
+            readonly 'file-max-size': v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>>>]>;
+    readonly sources: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly 'value-constructor': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly 'validation-download-attachment-fn': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type AttachmentType = v.InferOutput<typeof AttachmentSchema>;
+export type AttachmentSchemaType = v.GenericSchema<AttachmentType>;
+declare const _default: AttachmentSchemaType;
+export default _default;

package/schemas/field/attachment/index.js

@@ -0,0 +1,38 @@
+import { array, literal, nullable, nullish, number, picklist, strictObject, string } from "valibot";
+import { createFieldDisplay } from "../common.js";
+const CommonAttachmentComponentParamsSchema = strictObject({
+    filetype: nullish(picklist([
+        'pdf',
+        'pdf-for-mark'
+    ])),
+    'file-max-size': nullish(number())
+});
+const AttachmentDisplaySchema = createFieldDisplay(strictObject({
+    component: literal('attachment'),
+    'component-params': nullish(strictObject({
+        ...CommonAttachmentComponentParamsSchema.entries,
+        multiplicity: nullish(number())
+    }))
+}), strictObject({
+    component: literal('attachment'),
+    'component-params': nullish(strictObject({
+        ...CommonAttachmentComponentParamsSchema.entries,
+        coordinates: nullish(array(nullable(number())))
+    }))
+}));
+const AttachmentSchema = strictObject({
+    'user-input-mode': picklist([
+        'noinput',
+        'optional',
+        'required',
+        'display'
+    ]),
+    datatype: nullish(literal('attachment')),
+    attribute: nullish(string()),
+    display: AttachmentDisplaySchema,
+    sources: nullish(string()),
+    'value-constructor': nullish(string()),
+    'validation-download-attachment-fn': nullish(string())
+});
+const attachment = AttachmentSchema;
+export { attachment as default };

package/schemas/field/captcha/index.d.ts

@@ -0,0 +1,48 @@
+import * as v from 'valibot';
+declare const CaptchaSchema: v.StrictObjectSchema<{
+    readonly 'user-input-mode': v.PicklistSchema<["noinput", "optional", "required"], undefined>;
+    readonly display: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, v.RawCheckAction<import("../common.js").DisplayType<v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"captcha", undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"captcha", undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"captcha", undefined>;
+    }, undefined>>>]>;
+}, undefined>;
+export type CaptchaType = v.InferOutput<typeof CaptchaSchema>;
+export type CaptchaSchemaType = v.GenericSchema<CaptchaType>;
+declare const _default: CaptchaSchemaType;
+export default _default;

package/schemas/field/captcha/index.js

@@ -0,0 +1,15 @@
+import { literal, picklist, strictObject } from "valibot";
+import { createFieldDisplay } from "../common.js";
+const CaptchaDisplaySchema = createFieldDisplay(strictObject({
+    component: literal('captcha')
+}));
+const CaptchaSchema = strictObject({
+    'user-input-mode': picklist([
+        'noinput',
+        'optional',
+        'required'
+    ]),
+    display: CaptchaDisplaySchema
+});
+const captcha = CaptchaSchema;
+export { captcha as default };

package/schemas/field/choice/index.d.ts

@@ -0,0 +1,73 @@
+import * as v from 'valibot';
+declare const ChoiceSchema: v.StrictObjectSchema<{
+    readonly 'user-input-mode': v.PicklistSchema<["noinput", "optional", "required"], undefined>;
+    readonly display: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, v.RawCheckAction<import("../common.js").DisplayType<v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"choice", undefined>;
+        readonly choices: v.NullishSchema<v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+        readonly 'choices-order': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly 'component-params': v.NullishSchema<v.StrictObjectSchema<{
+            readonly autocomplete: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly 'legacy-mode': v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly 'format-title': v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"choice", undefined>;
+        readonly choices: v.NullishSchema<v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+        readonly 'choices-order': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly 'component-params': v.NullishSchema<v.StrictObjectSchema<{
+            readonly autocomplete: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly 'legacy-mode': v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly 'format-title': v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+        readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+            readonly md: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+    } & {
+        readonly component: v.LiteralSchema<"choice", undefined>;
+        readonly choices: v.NullishSchema<v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+        readonly 'choices-order': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+        readonly 'component-params': v.NullishSchema<v.StrictObjectSchema<{
+            readonly autocomplete: v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly 'legacy-mode': v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+            readonly 'format-title': v.NullishSchema<v.BooleanSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>>>]>;
+    readonly 'default-value': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly 'choices-source-fn': v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly attribute: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly datatype: v.NullishSchema<v.PicklistSchema<["choice", "string"], undefined>, undefined>;
+}, undefined>;
+export type ChoiceType = v.InferOutput<typeof ChoiceSchema>;
+export type ChoiceSchemaType = v.GenericSchema<ChoiceType>;
+declare const _default: ChoiceSchemaType;
+export default _default;

package/schemas/field/choice/index.js

@@ -0,0 +1,32 @@
+import { boolean as external_valibot_boolean, literal, nullish, picklist, record, strictObject, string, union } from "valibot";
+import { createFieldDisplay } from "../common.js";
+const ChoiceDisplaySchema = createFieldDisplay(strictObject({
+    component: literal('choice'),
+    choices: nullish(union([
+        string(),
+        record(string(), string())
+    ])),
+    'choices-order': nullish(string()),
+    'component-params': nullish(strictObject({
+        autocomplete: nullish(external_valibot_boolean()),
+        'legacy-mode': nullish(external_valibot_boolean()),
+        'format-title': nullish(external_valibot_boolean())
+    }))
+}));
+const ChoiceSchema = strictObject({
+    'user-input-mode': picklist([
+        'noinput',
+        'optional',
+        'required'
+    ]),
+    display: ChoiceDisplaySchema,
+    'default-value': nullish(string()),
+    'choices-source-fn': nullish(string()),
+    attribute: nullish(string()),
+    datatype: nullish(picklist([
+        'choice',
+        'string'
+    ]))
+});
+const choice = ChoiceSchema;
+export { choice as default };

package/schemas/field/common.d.ts

@@ -0,0 +1,82 @@
+import * as v from 'valibot';
+import { DisplayLang } from '../common.js';
+export declare const DisplayModeAndLangSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.PicklistSchema<["default", "web", "pdf"], undefined>, v.SchemaWithPipe<readonly [v.RecordSchema<v.PicklistSchema<["default", "el", "en", "fr"], undefined>, v.AnySchema, undefined>, v.CheckAction<{
+    default?: any;
+    el?: any;
+    en?: any;
+    fr?: any;
+}, "At least one display lang must be defined.">]>, undefined>, v.CheckAction<{
+    default?: {
+        default?: any;
+        el?: any;
+        en?: any;
+        fr?: any;
+    } | undefined;
+    web?: {
+        default?: any;
+        el?: any;
+        en?: any;
+        fr?: any;
+    } | undefined;
+    pdf?: {
+        default?: any;
+        el?: any;
+        en?: any;
+        fr?: any;
+    } | undefined;
+}, "At least one display mode must be defined.">]>;
+type AnyGenericSchema = v.GenericSchema<unknown, unknown>;
+export interface DisplayType<DefaultDisplaySchema extends AnyGenericSchema, WebDisplaySchema extends AnyGenericSchema = AnyGenericSchema, PdfDisplaySchema extends AnyGenericSchema = AnyGenericSchema> {
+    default?: Partial<Record<DisplayLang, v.InferOutput<DefaultDisplaySchema> | (unknown & Record<never, never>)>>;
+    web?: Partial<Record<DisplayLang, v.InferOutput<WebDisplaySchema> | (unknown & Record<never, never>)>>;
+    pdf?: Partial<Record<DisplayLang, v.InferOutput<PdfDisplaySchema> | (unknown & Record<never, never>)>>;
+}
+/**
+ * Creates a field display schema with specified default and PDF display properties.
+ *
+ * Defaults are:
+ * - title
+ * - title_md
+ * - value_md
+ * - hint
+ * - hint_md
+ * - template_hint
+ * - layout
+ *   - md
+ * - example
+ */
+export declare function createFieldDisplay<D extends v.ObjectEntries, P extends v.ObjectEntries = never>(DefaultDisplay: v.StrictObjectSchema<D, undefined> | v.LooseObjectSchema<D, undefined>, PdfDisplay?: v.StrictObjectSchema<P, undefined> | v.LooseObjectSchema<P, undefined>): v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, v.RawCheckAction<DisplayType<v.ObjectSchema<{
+    readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+    readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+    readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+        readonly md: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+} & D, undefined>, v.ObjectSchema<{
+    readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+    readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+    readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+        readonly md: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+} & D, undefined>, v.ObjectSchema<{
+    readonly title: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly title_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+    readonly value_md: v.NullishSchema<v.NumberSchema<undefined>, undefined>;
+    readonly hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly hint_md: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly template_hint: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly example: v.NullishSchema<v.StringSchema<undefined>, undefined>;
+    readonly layout: v.NullishSchema<v.StrictObjectSchema<{
+        readonly md: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+} & D, undefined>>>]>;
+export {};

package/schemas/field/common.js

@@ -0,0 +1,63 @@
+import { any, check, looseObject, nullish, number, pipe, rawCheck, record, safeParse, strictObject, string } from "valibot";
+import { DisplayLangSchema, DisplayModeSchema } from "../common.js";
+import { resolveDisplay } from "../resolve.js";
+import { isFailureDataset } from "../../utils/index.js";
+const FieldDisplayLangSchema = pipe(record(DisplayLangSchema, any()), check((val)=>{
+    if (!val) return false;
+    if (0 === Object.keys(val).length) return false;
+    return true;
+}, 'At least one display lang must be defined.'));
+const DisplayModeAndLangSchema = pipe(record(DisplayModeSchema, FieldDisplayLangSchema), check((val)=>{
+    if (!val) return false;
+    if (0 === Object.keys(val).length) return false;
+    return true;
+}, 'At least one display mode must be defined.'));
+function createFieldDisplay(DefaultDisplay, PdfDisplay) {
+    const baseObjectSchema = isLooseObject(DefaultDisplay) ? looseObject : strictObject;
+    const defaultDisplayContent = baseObjectSchema({
+        ...FieldDisplayModeBaseSchema.entries,
+        ...DefaultDisplay.entries
+    });
+    const defaultDisplaySchema = record(string(), record(string(), defaultDisplayContent));
+    const DisplaySchema = pipe(record(string(), any()), rawCheck(({ addIssue, dataset })=>{
+        if (isFailureDataset(dataset)) return;
+        const display = dataset.value;
+        DisplayModeSchema.options.forEach((displayMode)=>{
+            if (!(displayMode in display && display[displayMode]) || 'pdf' === displayMode) return;
+            Object.keys(display[displayMode]).forEach((displayLang)=>{
+                const resolvedDisplay = resolveDisplay(displayMode, displayLang, display);
+                const displaySchema = defaultDisplaySchema;
+                const result = safeParse(displaySchema, {
+                    [displayMode]: {
+                        [displayLang]: resolvedDisplay
+                    }
+                });
+                if (result.issues) result.issues.forEach((issue)=>{
+                    addIssue({
+                        message: issue.message,
+                        path: issue.path,
+                        input: issue.input,
+                        expected: issue.expected ?? void 0,
+                        received: issue.received,
+                        label: 'Display schema'
+                    });
+                });
+            });
+        });
+    }));
+    return DisplaySchema;
+}
+const isLooseObject = (schema)=>'loose_object' === schema.type;
+const FieldDisplayModeBaseSchema = strictObject({
+    title: nullish(string()),
+    title_md: nullish(number()),
+    value_md: nullish(number()),
+    hint: nullish(string()),
+    hint_md: nullish(string()),
+    template_hint: nullish(string()),
+    example: nullish(string()),
+    layout: nullish(strictObject({
+        md: string()
+    }))
+});
+export { DisplayModeAndLangSchema, createFieldDisplay };