@webiny/api-headless-cms 0.0.0-unstable.e53eceafb5 → 0.0.0-unstable.e6f0dc8ca7

package/features/modelBuilder/fields/DateTimeFieldType.js

@@ -0,0 +1,87 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+class DateTimeFieldBuilder extends DataFieldBuilder {
+  constructor() {
+    super("datetime");
+  }
+  required(message) {
+    return this.validation({
+      name: "required",
+      message: message || "Value is required.",
+      settings: {}
+    });
+  }
+  dateTimeType(type) {
+    this.config.settings = this.config.settings || {};
+    this.config.settings.type = type;
+    return this;
+  }
+
+  /**
+   * Just a calendar date, no time, no timezone. Useful for things like birthdays, holidays, or due dates where the time of day doesn't matter.
+   * Example: 2026-04-30
+   */
+  dateOnly() {
+    return this.dateTimeType("date");
+  }
+
+  /**
+   * Time in 24-hours format.
+   * Example: 19:35
+   */
+  timeOnly() {
+    return this.dateTimeType("time");
+  }
+
+  /**
+   * This is an ISO 8601 datetime with an explicit timezone offset.
+   * Example: 2026-04-29T13:25:00+02:00
+   */
+  withTimezone() {
+    return this.dateTimeType("dateTimeWithTimezone");
+  }
+
+  /**
+   * This is an ISO 8601 datetime in UTC (Zulu time). "Z" means "this is UTC, no offset."
+   * Example: 2026-04-30T13:25:00.000Z
+   */
+  withoutTimezone() {
+    return this.dateTimeType("dateTimeWithoutTimezone");
+  }
+  dateGte(value, message) {
+    const type = this.config.settings?.type || "date";
+    return this.validation({
+      name: "dateGte",
+      message: message || "Date/time is earlier than the provided one.",
+      settings: {
+        value,
+        type
+      }
+    });
+  }
+  dateLte(value, message) {
+    const type = this.config.settings?.type || "date";
+    return this.validation({
+      name: "dateLte",
+      message: message || "Date/time is later than the provided one.",
+      settings: {
+        value,
+        type
+      }
+    });
+  }
+}
+class DateTimeFieldTypeFactory {
+  type = "datetime";
+  create() {
+    return new DateTimeFieldBuilder();
+  }
+}
+export const DateTimeFieldType = FieldType.createImplementation({
+  implementation: DateTimeFieldTypeFactory,
+  dependencies: []
+});
+
+// Module augmentation for TypeScript autocomplete
+
+//# sourceMappingURL=DateTimeFieldType.js.map

package/features/modelBuilder/fields/DateTimeFieldType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","DataFieldBuilder","DateTimeFieldBuilder","constructor","required","message","validation","name","settings","dateTimeType","type","config","dateOnly","timeOnly","withTimezone","withoutTimezone","dateGte","value","dateLte","DateTimeFieldTypeFactory","create","DateTimeFieldType","createImplementation","implementation","dependencies"],"sources":["DateTimeFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { DataFieldBuilder } from \"./FieldBuilder.js\";\nimport { RequiredValidator, DateGteValidator, DateLteValidator } from \"./fieldTypeValidator.js\";\n\nexport type DateTimeType = \"date\" | \"time\" | \"dateTimeWithTimezone\" | \"dateTimeWithoutTimezone\";\n\nexport interface IDateTimeFieldBuilder\n    extends DataFieldBuilder<\"datetime\">, RequiredValidator, DateGteValidator, DateLteValidator {\n    dateTimeType(type: DateTimeType): this;\n    dateOnly(): this;\n    timeOnly(): this;\n    withTimezone(): this;\n    withoutTimezone(): this;\n}\n\nclass DateTimeFieldBuilder extends DataFieldBuilder<\"datetime\"> implements IDateTimeFieldBuilder {\n    public constructor() {\n        super(\"datetime\");\n    }\n\n    required(message?: string): this {\n        return this.validation({\n            name: \"required\",\n            message: message || \"Value is required.\",\n            settings: {}\n        });\n    }\n\n    dateTimeType(type: DateTimeType): this {\n        this.config.settings = this.config.settings || {};\n        this.config.settings.type = type;\n        return this;\n    }\n\n    /**\n     * Just a calendar date, no time, no timezone. Useful for things like birthdays, holidays, or due dates where the time of day doesn't matter.\n     * Example: 2026-04-30\n     */\n    dateOnly(): this {\n        return this.dateTimeType(\"date\");\n    }\n\n    /**\n     * Time in 24-hours format.\n     * Example: 19:35\n     */\n    timeOnly(): this {\n        return this.dateTimeType(\"time\");\n    }\n\n    /**\n     * This is an ISO 8601 datetime with an explicit timezone offset.\n     * Example: 2026-04-29T13:25:00+02:00\n     */\n    withTimezone(): this {\n        return this.dateTimeType(\"dateTimeWithTimezone\");\n    }\n\n    /**\n     * This is an ISO 8601 datetime in UTC (Zulu time). \"Z\" means \"this is UTC, no offset.\"\n     * Example: 2026-04-30T13:25:00.000Z\n     */\n    withoutTimezone(): this {\n        return this.dateTimeType(\"dateTimeWithoutTimezone\");\n    }\n\n    dateGte(value: string, message?: string): this {\n        const type = this.config.settings?.type || \"date\";\n        return this.validation({\n            name: \"dateGte\",\n            message: message || \"Date/time is earlier than the provided one.\",\n            settings: { value, type }\n        });\n    }\n\n    dateLte(value: string, message?: string): this {\n        const type = this.config.settings?.type || \"date\";\n        return this.validation({\n            name: \"dateLte\",\n            message: message || \"Date/time is later than the provided one.\",\n            settings: { value, type }\n        });\n    }\n}\n\nclass DateTimeFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"datetime\";\n\n    create(): IDateTimeFieldBuilder {\n        return new DateTimeFieldBuilder();\n    }\n}\n\nexport const DateTimeFieldType = FieldType.createImplementation({\n    implementation: DateTimeFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        datetime(): IDateTimeFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAClB,SAASC,gBAAgB;AAczB,MAAMC,oBAAoB,SAASD,gBAAgB,CAA8C;EACtFE,WAAWA,CAAA,EAAG;IACjB,KAAK,CAAC,UAAU,CAAC;EACrB;EAEAC,QAAQA,CAACC,OAAgB,EAAQ;IAC7B,OAAO,IAAI,CAACC,UAAU,CAAC;MACnBC,IAAI,EAAE,UAAU;MAChBF,OAAO,EAAEA,OAAO,IAAI,oBAAoB;MACxCG,QAAQ,EAAE,CAAC;IACf,CAAC,CAAC;EACN;EAEAC,YAAYA,CAACC,IAAkB,EAAQ;IACnC,IAAI,CAACC,MAAM,CAACH,QAAQ,GAAG,IAAI,CAACG,MAAM,CAACH,QAAQ,IAAI,CAAC,CAAC;IACjD,IAAI,CAACG,MAAM,CAACH,QAAQ,CAACE,IAAI,GAAGA,IAAI;IAChC,OAAO,IAAI;EACf;;EAEA;AACJ;AACA;AACA;EACIE,QAAQA,CAAA,EAAS;IACb,OAAO,IAAI,CAACH,YAAY,CAAC,MAAM,CAAC;EACpC;;EAEA;AACJ;AACA;AACA;EACII,QAAQA,CAAA,EAAS;IACb,OAAO,IAAI,CAACJ,YAAY,CAAC,MAAM,CAAC;EACpC;;EAEA;AACJ;AACA;AACA;EACIK,YAAYA,CAAA,EAAS;IACjB,OAAO,IAAI,CAACL,YAAY,CAAC,sBAAsB,CAAC;EACpD;;EAEA;AACJ;AACA;AACA;EACIM,eAAeA,CAAA,EAAS;IACpB,OAAO,IAAI,CAACN,YAAY,CAAC,yBAAyB,CAAC;EACvD;EAEAO,OAAOA,CAACC,KAAa,EAAEZ,OAAgB,EAAQ;IAC3C,MAAMK,IAAI,GAAG,IAAI,CAACC,MAAM,CAACH,QAAQ,EAAEE,IAAI,IAAI,MAAM;IACjD,OAAO,IAAI,CAACJ,UAAU,CAAC;MACnBC,IAAI,EAAE,SAAS;MACfF,OAAO,EAAEA,OAAO,IAAI,6CAA6C;MACjEG,QAAQ,EAAE;QAAES,KAAK;QAAEP;MAAK;IAC5B,CAAC,CAAC;EACN;EAEAQ,OAAOA,CAACD,KAAa,EAAEZ,OAAgB,EAAQ;IAC3C,MAAMK,IAAI,GAAG,IAAI,CAACC,MAAM,CAACH,QAAQ,EAAEE,IAAI,IAAI,MAAM;IACjD,OAAO,IAAI,CAACJ,UAAU,CAAC;MACnBC,IAAI,EAAE,SAAS;MACfF,OAAO,EAAEA,OAAO,IAAI,2CAA2C;MAC/DG,QAAQ,EAAE;QAAES,KAAK;QAAEP;MAAK;IAC5B,CAAC,CAAC;EACN;AACJ;AAEA,MAAMS,wBAAwB,CAA8B;EAC/CT,IAAI,GAAG,UAAU;EAE1BU,MAAMA,CAAA,EAA0B;IAC5B,OAAO,IAAIlB,oBAAoB,CAAC,CAAC;EACrC;AACJ;AAEA,OAAO,MAAMmB,iBAAiB,GAAGrB,SAAS,CAACsB,oBAAoB,CAAC;EAC5DC,cAAc,EAAEJ,wBAAwB;EACxCK,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

package/features/modelBuilder/fields/DynamicZoneFieldType.d.ts

@@ -0,0 +1,28 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { DataFieldBuilder, type BaseFieldBuilder } from "./FieldBuilder.js";
+import { type IFieldBuilderRegistry } from "../abstractions.js";
+import type { CmsIcon } from "../../../types/index.js";
+export interface IDynamicZoneFieldBuilder extends DataFieldBuilder<"dynamicZone"> {
+    required(message?: string): this;
+    template(id: string, config: {
+        name: string;
+        gqlTypeName: string;
+        icon?: CmsIcon;
+        description?: string;
+        fields: (registry: IFieldBuilderRegistry) => Record<string, BaseFieldBuilder<any>>;
+        layout?: string[][];
+    }): this;
+}
+declare class DynamicZoneFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "dynamicZone";
+    create(registry: IFieldBuilderRegistry): IDynamicZoneFieldBuilder;
+}
+export declare const DynamicZoneFieldType: typeof DynamicZoneFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        dynamicZone(): IDynamicZoneFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/DynamicZoneFieldType.js

@@ -0,0 +1,64 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+class DynamicZoneFieldBuilder extends DataFieldBuilder {
+  templates = [];
+  constructor(registry) {
+    super("dynamicZone");
+    this.registry = registry;
+  }
+  required(message) {
+    return this.validation({
+      name: "required",
+      message: message || "Field is required",
+      settings: {}
+    });
+  }
+  template(id, config) {
+    const fieldBuilders = config.fields(this.registry);
+    const fields = [];
+    for (const [key, fieldBuilder] of Object.entries(fieldBuilders)) {
+      fieldBuilder.fieldId(key);
+      const result = fieldBuilder.build();
+      if (result.type === "data") {
+        fields.push(result.field);
+      } else if (result.fields) {
+        fields.push(...result.fields);
+      }
+    }
+    this.templates.push({
+      id,
+      name: config.name,
+      gqlTypeName: config.gqlTypeName,
+      icon: config.icon,
+      description: config.description || "",
+      fields,
+      layout: config.layout || [],
+      validation: []
+    });
+    return this;
+  }
+  build() {
+    // Set templates in settings before building
+    this.config.settings = this.config.settings || {};
+    this.config.settings.templates = this.templates;
+    this.config.listValidation = [{
+      name: "dynamicZone",
+      message: ""
+    }];
+    return super.build();
+  }
+}
+class DynamicZoneFieldTypeFactory {
+  type = "dynamicZone";
+  create(registry) {
+    return new DynamicZoneFieldBuilder(registry);
+  }
+}
+export const DynamicZoneFieldType = FieldType.createImplementation({
+  implementation: DynamicZoneFieldTypeFactory,
+  dependencies: []
+});
+
+// Module augmentation for TypeScript autocomplete
+
+//# sourceMappingURL=DynamicZoneFieldType.js.map

package/features/modelBuilder/fields/DynamicZoneFieldType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","DataFieldBuilder","DynamicZoneFieldBuilder","templates","constructor","registry","required","message","validation","name","settings","template","id","config","fieldBuilders","fields","key","fieldBuilder","Object","entries","fieldId","result","build","type","push","field","gqlTypeName","icon","description","layout","listValidation","DynamicZoneFieldTypeFactory","create","DynamicZoneFieldType","createImplementation","implementation","dependencies"],"sources":["DynamicZoneFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { type FieldBuildResult } from \"./BaseFieldBuilder.js\";\nimport { DataFieldBuilder, type BaseFieldBuilder } from \"./FieldBuilder.js\";\nimport { type IFieldBuilderRegistry } from \"../abstractions.js\";\nimport type { CmsIcon, CmsModelField, CmsModelFieldValidation } from \"~/types/index.js\";\n\ninterface IDynamicZoneTemplate {\n    id: string;\n    name: string;\n    gqlTypeName: string;\n    icon: CmsIcon | undefined;\n    description: string;\n    fields: any[];\n    layout: string[][];\n    validation: CmsModelFieldValidation[];\n}\n\nexport interface IDynamicZoneFieldBuilder extends DataFieldBuilder<\"dynamicZone\"> {\n    required(message?: string): this;\n    template(\n        id: string,\n        config: {\n            name: string;\n            gqlTypeName: string;\n            icon?: CmsIcon;\n            description?: string;\n            fields: (registry: IFieldBuilderRegistry) => Record<string, BaseFieldBuilder<any>>;\n            layout?: string[][];\n        }\n    ): this;\n}\n\ninterface IDynamicZoneFieldBuilderTemplateConfig {\n    name: string;\n    gqlTypeName: string;\n    icon?: CmsIcon;\n    description?: string;\n    fields: (registry: IFieldBuilderRegistry) => Record<string, BaseFieldBuilder<any>>;\n    layout?: string[][];\n}\n\nclass DynamicZoneFieldBuilder\n    extends DataFieldBuilder<\"dynamicZone\">\n    implements IDynamicZoneFieldBuilder\n{\n    private readonly templates: IDynamicZoneTemplate[] = [];\n\n    public constructor(private registry: IFieldBuilderRegistry) {\n        super(\"dynamicZone\");\n    }\n\n    public required(message?: string): this {\n        return this.validation({\n            name: \"required\",\n            message: message || \"Field is required\",\n            settings: {}\n        });\n    }\n\n    public template(id: string, config: IDynamicZoneFieldBuilderTemplateConfig): this {\n        const fieldBuilders = config.fields(this.registry);\n        const fields: CmsModelField[] = [];\n\n        for (const [key, fieldBuilder] of Object.entries(fieldBuilders)) {\n            fieldBuilder.fieldId(key);\n            const result: FieldBuildResult = (fieldBuilder as any).build();\n            if (result.type === \"data\") {\n                fields.push(result.field);\n            } else if (result.fields) {\n                fields.push(...result.fields);\n            }\n        }\n\n        this.templates.push({\n            id,\n            name: config.name,\n            gqlTypeName: config.gqlTypeName,\n            icon: config.icon,\n            description: config.description || \"\",\n            fields,\n            layout: config.layout || [],\n            validation: []\n        });\n\n        return this;\n    }\n\n    public override build() {\n        // Set templates in settings before building\n        this.config.settings = this.config.settings || {};\n        this.config.settings.templates = this.templates;\n        this.config.listValidation = [{ name: \"dynamicZone\", message: \"\" }];\n        return super.build();\n    }\n}\n\nclass DynamicZoneFieldTypeFactory implements IFieldTypeFactory {\n    public readonly type = \"dynamicZone\";\n\n    public create(registry: IFieldBuilderRegistry): IDynamicZoneFieldBuilder {\n        return new DynamicZoneFieldBuilder(registry);\n    }\n}\n\nexport const DynamicZoneFieldType = FieldType.createImplementation({\n    implementation: DynamicZoneFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        dynamicZone(): IDynamicZoneFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAElB,SAASC,gBAAgB;AAuCzB,MAAMC,uBAAuB,SACjBD,gBAAgB,CAE5B;EACqBE,SAAS,GAA2B,EAAE;EAEhDC,WAAWA,CAASC,QAA+B,EAAE;IACxD,KAAK,CAAC,aAAa,CAAC;IAAC,KADEA,QAA+B,GAA/BA,QAA+B;EAE1D;EAEOC,QAAQA,CAACC,OAAgB,EAAQ;IACpC,OAAO,IAAI,CAACC,UAAU,CAAC;MACnBC,IAAI,EAAE,UAAU;MAChBF,OAAO,EAAEA,OAAO,IAAI,mBAAmB;MACvCG,QAAQ,EAAE,CAAC;IACf,CAAC,CAAC;EACN;EAEOC,QAAQA,CAACC,EAAU,EAAEC,MAA8C,EAAQ;IAC9E,MAAMC,aAAa,GAAGD,MAAM,CAACE,MAAM,CAAC,IAAI,CAACV,QAAQ,CAAC;IAClD,MAAMU,MAAuB,GAAG,EAAE;IAElC,KAAK,MAAM,CAACC,GAAG,EAAEC,YAAY,CAAC,IAAIC,MAAM,CAACC,OAAO,CAACL,aAAa,CAAC,EAAE;MAC7DG,YAAY,CAACG,OAAO,CAACJ,GAAG,CAAC;MACzB,MAAMK,MAAwB,GAAIJ,YAAY,CAASK,KAAK,CAAC,CAAC;MAC9D,IAAID,MAAM,CAACE,IAAI,KAAK,MAAM,EAAE;QACxBR,MAAM,CAACS,IAAI,CAACH,MAAM,CAACI,KAAK,CAAC;MAC7B,CAAC,MAAM,IAAIJ,MAAM,CAACN,MAAM,EAAE;QACtBA,MAAM,CAACS,IAAI,CAAC,GAAGH,MAAM,CAACN,MAAM,CAAC;MACjC;IACJ;IAEA,IAAI,CAACZ,SAAS,CAACqB,IAAI,CAAC;MAChBZ,EAAE;MACFH,IAAI,EAAEI,MAAM,CAACJ,IAAI;MACjBiB,WAAW,EAAEb,MAAM,CAACa,WAAW;MAC/BC,IAAI,EAAEd,MAAM,CAACc,IAAI;MACjBC,WAAW,EAAEf,MAAM,CAACe,WAAW,IAAI,EAAE;MACrCb,MAAM;MACNc,MAAM,EAAEhB,MAAM,CAACgB,MAAM,IAAI,EAAE;MAC3BrB,UAAU,EAAE;IAChB,CAAC,CAAC;IAEF,OAAO,IAAI;EACf;EAEgBc,KAAKA,CAAA,EAAG;IACpB;IACA,IAAI,CAACT,MAAM,CAACH,QAAQ,GAAG,IAAI,CAACG,MAAM,CAACH,QAAQ,IAAI,CAAC,CAAC;IACjD,IAAI,CAACG,MAAM,CAACH,QAAQ,CAACP,SAAS,GAAG,IAAI,CAACA,SAAS;IAC/C,IAAI,CAACU,MAAM,CAACiB,cAAc,GAAG,CAAC;MAAErB,IAAI,EAAE,aAAa;MAAEF,OAAO,EAAE;IAAG,CAAC,CAAC;IACnE,OAAO,KAAK,CAACe,KAAK,CAAC,CAAC;EACxB;AACJ;AAEA,MAAMS,2BAA2B,CAA8B;EAC3CR,IAAI,GAAG,aAAa;EAE7BS,MAAMA,CAAC3B,QAA+B,EAA4B;IACrE,OAAO,IAAIH,uBAAuB,CAACG,QAAQ,CAAC;EAChD;AACJ;AAEA,OAAO,MAAM4B,oBAAoB,GAAGjC,SAAS,CAACkC,oBAAoB,CAAC;EAC/DC,cAAc,EAAEJ,2BAA2B;EAC3CK,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

package/features/modelBuilder/fields/FieldBuilder.d.ts

@@ -0,0 +1,5 @@
+export { DataFieldBuilder } from "./DataFieldBuilder.js";
+export { LayoutFieldBuilder } from "./LayoutFieldBuilder.js";
+export { BaseFieldBuilder } from "./BaseFieldBuilder.js";
+export type { FieldBuildResult, DataFieldBuildResult, LayoutFieldBuildResult } from "./BaseFieldBuilder.js";
+export type { IFieldRendererRegistry, FieldRendererName, FieldRendererSettings, FieldBuilderConfig } from "./DataFieldBuilder.js";

package/features/modelBuilder/fields/FieldBuilder.js

@@ -0,0 +1,5 @@
+export { DataFieldBuilder } from "./DataFieldBuilder.js";
+export { LayoutFieldBuilder } from "./LayoutFieldBuilder.js";
+export { BaseFieldBuilder } from "./BaseFieldBuilder.js";
+
+//# sourceMappingURL=FieldBuilder.js.map

package/features/modelBuilder/fields/FieldBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DataFieldBuilder","LayoutFieldBuilder","BaseFieldBuilder"],"sources":["FieldBuilder.ts"],"sourcesContent":["export { DataFieldBuilder } from \"./DataFieldBuilder.js\";\nexport { LayoutFieldBuilder } from \"./LayoutFieldBuilder.js\";\nexport { BaseFieldBuilder } from \"./BaseFieldBuilder.js\";\nexport type {\n    FieldBuildResult,\n    DataFieldBuildResult,\n    LayoutFieldBuildResult\n} from \"./BaseFieldBuilder.js\";\nexport type {\n    IFieldRendererRegistry,\n    FieldRendererName,\n    FieldRendererSettings,\n    FieldBuilderConfig\n} from \"./DataFieldBuilder.js\";\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,kBAAkB;AAC3B,SAASC,gBAAgB","ignoreList":[]}

package/features/modelBuilder/fields/FieldBuilderRegistry.d.ts

@@ -0,0 +1,4 @@
+import { FieldBuilderRegistry as RegistryAbstraction } from "../abstractions.js";
+export declare const FieldBuilderRegistry: import("@webiny/di").Constructor<RegistryAbstraction.Interface> & {
+    __abstraction: import("@webiny/di").Abstraction<RegistryAbstraction.Interface>;
+};

package/features/modelBuilder/fields/FieldBuilderRegistry.js

@@ -0,0 +1,71 @@
+/**
+ * This file has multiple @ts-expect-error comments because the dynamic nature of the registry makes it difficult to type correctly.
+ * The registry is designed to allow dynamic method access for field types, which is not easily expressed in TypeScript.
+ * The @ts-expect-error comments are used to suppress type errors in places where we know the code is correct but TypeScript cannot verify it.
+ */
+import camelCase from "lodash/camelCase.js";
+import { FieldBuilderRegistry as RegistryAbstraction } from "../abstractions.js";
+import { FieldType } from "./abstractions.js";
+
+// @ts-expect-error
+class FieldBuilderRegistryImpl {
+  fieldTypes = new Map();
+  extendMode = false;
+  constructor(fieldTypeFactories) {
+    // Register all field types by their type name
+    for (const factory of fieldTypeFactories) {
+      this.fieldTypes.set(factory.type, factory);
+      // Also register camelCase aliases for hyphenated types
+      if (factory.type.includes("-")) {
+        this.fieldTypes.set(camelCase(factory.type), factory);
+      }
+      // also register camelCase aliases for subtypes.
+      if (factory.type.includes(":")) {
+        this.fieldTypes.set(camelCase(factory.type), factory);
+      }
+    }
+
+    // Return Proxy for dynamic method access
+    const proxy = new Proxy(this, {
+      get(target, prop) {
+        // Handle extend() method
+        if (prop === "extend") {
+          return () => {
+            target.extendMode = true;
+            return proxy;
+          };
+        }
+
+        // Check if it's a registered field type
+        const factory = target.fieldTypes.get(prop);
+        if (factory) {
+          return () => {
+            const builder = factory.create(proxy);
+
+            // If in extend mode, mark the builder with extend flag
+            // BaseModelBuilder will handle merging operations by field ID
+            if (target.extendMode) {
+              builder._extendMode = true;
+              target.extendMode = false; // Reset for next field
+            }
+            return builder;
+          };
+        }
+
+        // Otherwise return the actual property
+        return target[prop];
+      }
+    });
+    return proxy;
+  }
+}
+export const FieldBuilderRegistry = RegistryAbstraction.createImplementation({
+  // @ts-expect-error
+  implementation: FieldBuilderRegistryImpl,
+  // @ts-expect-error
+  dependencies: [[FieldType, {
+    multiple: true
+  }]]
+});
+
+//# sourceMappingURL=FieldBuilderRegistry.js.map

package/features/modelBuilder/fields/FieldBuilderRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["camelCase","FieldBuilderRegistry","RegistryAbstraction","FieldType","FieldBuilderRegistryImpl","fieldTypes","Map","extendMode","constructor","fieldTypeFactories","factory","set","type","includes","proxy","Proxy","get","target","prop","builder","create","_extendMode","createImplementation","implementation","dependencies","multiple"],"sources":["FieldBuilderRegistry.ts"],"sourcesContent":["/**\n * This file has multiple @ts-expect-error comments because the dynamic nature of the registry makes it difficult to type correctly.\n * The registry is designed to allow dynamic method access for field types, which is not easily expressed in TypeScript.\n * The @ts-expect-error comments are used to suppress type errors in places where we know the code is correct but TypeScript cannot verify it.\n */\nimport camelCase from \"lodash/camelCase.js\";\nimport {\n    FieldBuilderRegistry as RegistryAbstraction,\n    type IFieldBuilderRegistry\n} from \"../abstractions.js\";\nimport { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\n\n// @ts-expect-error\nclass FieldBuilderRegistryImpl implements IFieldBuilderRegistry {\n    private fieldTypes = new Map<string, IFieldTypeFactory>();\n    private extendMode = false;\n    public existingFields?: Map<string, any>;\n\n    public constructor(fieldTypeFactories: IFieldTypeFactory[]) {\n        // Register all field types by their type name\n        for (const factory of fieldTypeFactories) {\n            this.fieldTypes.set(factory.type, factory);\n            // Also register camelCase aliases for hyphenated types\n            if (factory.type.includes(\"-\")) {\n                this.fieldTypes.set(camelCase(factory.type), factory);\n            }\n            // also register camelCase aliases for subtypes.\n            if (factory.type.includes(\":\")) {\n                this.fieldTypes.set(camelCase(factory.type), factory);\n            }\n        }\n\n        // Return Proxy for dynamic method access\n        const proxy = new Proxy(this, {\n            get(target, prop: string) {\n                // Handle extend() method\n                if (prop === \"extend\") {\n                    return () => {\n                        target.extendMode = true;\n                        return proxy;\n                    };\n                }\n\n                // Check if it's a registered field type\n                const factory = target.fieldTypes.get(prop);\n                if (factory) {\n                    return () => {\n                        const builder = factory.create(proxy as IFieldBuilderRegistry);\n\n                        // If in extend mode, mark the builder with extend flag\n                        // BaseModelBuilder will handle merging operations by field ID\n                        if (target.extendMode) {\n                            (builder as any)._extendMode = true;\n                            target.extendMode = false; // Reset for next field\n                        }\n\n                        return builder;\n                    };\n                }\n\n                // Otherwise return the actual property\n                return target[prop as keyof typeof target];\n            }\n        }) as any;\n\n        return proxy;\n    }\n}\n\nexport const FieldBuilderRegistry = RegistryAbstraction.createImplementation({\n    // @ts-expect-error\n    implementation: FieldBuilderRegistryImpl,\n    // @ts-expect-error\n    dependencies: [[FieldType, { multiple: true }]]\n});\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,OAAOA,SAAS,MAAM,qBAAqB;AAC3C,SACIC,oBAAoB,IAAIC,mBAAmB;AAG/C,SAASC,SAAS;;AAElB;AACA,MAAMC,wBAAwB,CAAkC;EACpDC,UAAU,GAAG,IAAIC,GAAG,CAA4B,CAAC;EACjDC,UAAU,GAAG,KAAK;EAGnBC,WAAWA,CAACC,kBAAuC,EAAE;IACxD;IACA,KAAK,MAAMC,OAAO,IAAID,kBAAkB,EAAE;MACtC,IAAI,CAACJ,UAAU,CAACM,GAAG,CAACD,OAAO,CAACE,IAAI,EAAEF,OAAO,CAAC;MAC1C;MACA,IAAIA,OAAO,CAACE,IAAI,CAACC,QAAQ,CAAC,GAAG,CAAC,EAAE;QAC5B,IAAI,CAACR,UAAU,CAACM,GAAG,CAACX,SAAS,CAACU,OAAO,CAACE,IAAI,CAAC,EAAEF,OAAO,CAAC;MACzD;MACA;MACA,IAAIA,OAAO,CAACE,IAAI,CAACC,QAAQ,CAAC,GAAG,CAAC,EAAE;QAC5B,IAAI,CAACR,UAAU,CAACM,GAAG,CAACX,SAAS,CAACU,OAAO,CAACE,IAAI,CAAC,EAAEF,OAAO,CAAC;MACzD;IACJ;;IAEA;IACA,MAAMI,KAAK,GAAG,IAAIC,KAAK,CAAC,IAAI,EAAE;MAC1BC,GAAGA,CAACC,MAAM,EAAEC,IAAY,EAAE;QACtB;QACA,IAAIA,IAAI,KAAK,QAAQ,EAAE;UACnB,OAAO,MAAM;YACTD,MAAM,CAACV,UAAU,GAAG,IAAI;YACxB,OAAOO,KAAK;UAChB,CAAC;QACL;;QAEA;QACA,MAAMJ,OAAO,GAAGO,MAAM,CAACZ,UAAU,CAACW,GAAG,CAACE,IAAI,CAAC;QAC3C,IAAIR,OAAO,EAAE;UACT,OAAO,MAAM;YACT,MAAMS,OAAO,GAAGT,OAAO,CAACU,MAAM,CAACN,KAA8B,CAAC;;YAE9D;YACA;YACA,IAAIG,MAAM,CAACV,UAAU,EAAE;cAClBY,OAAO,CAASE,WAAW,GAAG,IAAI;cACnCJ,MAAM,CAACV,UAAU,GAAG,KAAK,CAAC,CAAC;YAC/B;YAEA,OAAOY,OAAO;UAClB,CAAC;QACL;;QAEA;QACA,OAAOF,MAAM,CAACC,IAAI,CAAwB;MAC9C;IACJ,CAAC,CAAQ;IAET,OAAOJ,KAAK;EAChB;AACJ;AAEA,OAAO,MAAMb,oBAAoB,GAAGC,mBAAmB,CAACoB,oBAAoB,CAAC;EACzE;EACAC,cAAc,EAAEnB,wBAAwB;EACxC;EACAoB,YAAY,EAAE,CAAC,CAACrB,SAAS,EAAE;IAAEsB,QAAQ,EAAE;EAAK,CAAC,CAAC;AAClD,CAAC,CAAC","ignoreList":[]}

package/features/modelBuilder/fields/FileFieldType.d.ts

@@ -0,0 +1,19 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+import { RequiredValidator } from "./fieldTypeValidator.js";
+export interface IFileFieldBuilder extends DataFieldBuilder<"file">, RequiredValidator {
+    imagesOnly(): this;
+}
+declare class FileFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "file";
+    create(): IFileFieldBuilder;
+}
+export declare const FileFieldType: typeof FileFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        file(): IFileFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/FileFieldType.js

@@ -0,0 +1,33 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+class FileFieldBuilder extends DataFieldBuilder {
+  constructor() {
+    super("file");
+  }
+  required(message) {
+    return this.validation({
+      name: "required",
+      message: message || "Value is required.",
+      settings: {}
+    });
+  }
+  imagesOnly() {
+    this.config.settings = this.config.settings || {};
+    this.config.settings.imagesOnly = true;
+    return this;
+  }
+}
+class FileFieldTypeFactory {
+  type = "file";
+  create() {
+    return new FileFieldBuilder();
+  }
+}
+export const FileFieldType = FieldType.createImplementation({
+  implementation: FileFieldTypeFactory,
+  dependencies: []
+});
+
+// Module augmentation for TypeScript autocomplete
+
+//# sourceMappingURL=FileFieldType.js.map

package/features/modelBuilder/fields/FileFieldType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","DataFieldBuilder","FileFieldBuilder","constructor","required","message","validation","name","settings","imagesOnly","config","FileFieldTypeFactory","type","create","FileFieldType","createImplementation","implementation","dependencies"],"sources":["FileFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { DataFieldBuilder } from \"./FieldBuilder.js\";\nimport { RequiredValidator } from \"./fieldTypeValidator.js\";\n\nexport interface IFileFieldBuilder extends DataFieldBuilder<\"file\">, RequiredValidator {\n    imagesOnly(): this;\n}\n\nclass FileFieldBuilder extends DataFieldBuilder<\"file\"> implements IFileFieldBuilder {\n    public constructor() {\n        super(\"file\");\n    }\n\n    required(message?: string): this {\n        return this.validation({\n            name: \"required\",\n            message: message || \"Value is required.\",\n            settings: {}\n        });\n    }\n\n    imagesOnly(): this {\n        this.config.settings = this.config.settings || {};\n        this.config.settings.imagesOnly = true;\n        return this;\n    }\n}\n\nclass FileFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"file\";\n\n    create(): IFileFieldBuilder {\n        return new FileFieldBuilder();\n    }\n}\n\nexport const FileFieldType = FieldType.createImplementation({\n    implementation: FileFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        file(): IFileFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAClB,SAASC,gBAAgB;AAOzB,MAAMC,gBAAgB,SAASD,gBAAgB,CAAsC;EAC1EE,WAAWA,CAAA,EAAG;IACjB,KAAK,CAAC,MAAM,CAAC;EACjB;EAEAC,QAAQA,CAACC,OAAgB,EAAQ;IAC7B,OAAO,IAAI,CAACC,UAAU,CAAC;MACnBC,IAAI,EAAE,UAAU;MAChBF,OAAO,EAAEA,OAAO,IAAI,oBAAoB;MACxCG,QAAQ,EAAE,CAAC;IACf,CAAC,CAAC;EACN;EAEAC,UAAUA,CAAA,EAAS;IACf,IAAI,CAACC,MAAM,CAACF,QAAQ,GAAG,IAAI,CAACE,MAAM,CAACF,QAAQ,IAAI,CAAC,CAAC;IACjD,IAAI,CAACE,MAAM,CAACF,QAAQ,CAACC,UAAU,GAAG,IAAI;IACtC,OAAO,IAAI;EACf;AACJ;AAEA,MAAME,oBAAoB,CAA8B;EAC3CC,IAAI,GAAG,MAAM;EAEtBC,MAAMA,CAAA,EAAsB;IACxB,OAAO,IAAIX,gBAAgB,CAAC,CAAC;EACjC;AACJ;AAEA,OAAO,MAAMY,aAAa,GAAGd,SAAS,CAACe,oBAAoB,CAAC;EACxDC,cAAc,EAAEL,oBAAoB;EACpCM,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

package/features/modelBuilder/fields/JsonFieldType.d.ts

@@ -0,0 +1,17 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+export interface IJsonFieldBuilder extends DataFieldBuilder<"json"> {
+}
+declare class JsonFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "json";
+    create(): IJsonFieldBuilder;
+}
+export declare const JsonFieldType: typeof JsonFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        json(): IJsonFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/JsonFieldType.js

@@ -0,0 +1,21 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+class JsonFieldBuilder extends DataFieldBuilder {
+  constructor() {
+    super("json");
+  }
+}
+class JsonFieldTypeFactory {
+  type = "json";
+  create() {
+    return new JsonFieldBuilder();
+  }
+}
+export const JsonFieldType = FieldType.createImplementation({
+  implementation: JsonFieldTypeFactory,
+  dependencies: []
+});
+
+// Module augmentation for TypeScript autocomplete
+
+//# sourceMappingURL=JsonFieldType.js.map

package/features/modelBuilder/fields/JsonFieldType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","DataFieldBuilder","JsonFieldBuilder","constructor","JsonFieldTypeFactory","type","create","JsonFieldType","createImplementation","implementation","dependencies"],"sources":["JsonFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { DataFieldBuilder } from \"./FieldBuilder.js\";\n\nexport interface IJsonFieldBuilder extends DataFieldBuilder<\"json\"> {}\n\nclass JsonFieldBuilder extends DataFieldBuilder<\"json\"> implements IJsonFieldBuilder {\n    public constructor() {\n        super(\"json\");\n    }\n}\n\nclass JsonFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"json\";\n\n    create(): IJsonFieldBuilder {\n        return new JsonFieldBuilder();\n    }\n}\n\nexport const JsonFieldType = FieldType.createImplementation({\n    implementation: JsonFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        json(): IJsonFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAClB,SAASC,gBAAgB;AAIzB,MAAMC,gBAAgB,SAASD,gBAAgB,CAAsC;EAC1EE,WAAWA,CAAA,EAAG;IACjB,KAAK,CAAC,MAAM,CAAC;EACjB;AACJ;AAEA,MAAMC,oBAAoB,CAA8B;EAC3CC,IAAI,GAAG,MAAM;EAEtBC,MAAMA,CAAA,EAAsB;IACxB,OAAO,IAAIJ,gBAAgB,CAAC,CAAC;EACjC;AACJ;AAEA,OAAO,MAAMK,aAAa,GAAGP,SAAS,CAACQ,oBAAoB,CAAC;EACxDC,cAAc,EAAEL,oBAAoB;EACpCM,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

package/features/modelBuilder/fields/LayoutFieldBuilder.d.ts

@@ -0,0 +1,7 @@
+import { BaseFieldBuilder } from "./BaseFieldBuilder.js";
+/**
+ * Slim base class for layout fields (separators, alerts, tabs, etc.).
+ * Layout fields only support label, description, help, and note — no list(), storageId(), etc.
+ */
+export declare abstract class LayoutFieldBuilder<TType extends string = string> extends BaseFieldBuilder<TType> {
+}

package/features/modelBuilder/fields/LayoutFieldBuilder.js

@@ -0,0 +1,9 @@
+import { BaseFieldBuilder } from "./BaseFieldBuilder.js";
+
+/**
+ * Slim base class for layout fields (separators, alerts, tabs, etc.).
+ * Layout fields only support label, description, help, and note — no list(), storageId(), etc.
+ */
+export class LayoutFieldBuilder extends BaseFieldBuilder {}
+
+//# sourceMappingURL=LayoutFieldBuilder.js.map

package/features/modelBuilder/fields/LayoutFieldBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BaseFieldBuilder","LayoutFieldBuilder"],"sources":["LayoutFieldBuilder.ts"],"sourcesContent":["import { BaseFieldBuilder } from \"./BaseFieldBuilder.js\";\n\n/**\n * Slim base class for layout fields (separators, alerts, tabs, etc.).\n * Layout fields only support label, description, help, and note — no list(), storageId(), etc.\n */\nexport abstract class LayoutFieldBuilder<\n    TType extends string = string\n> extends BaseFieldBuilder<TType> {}\n"],"mappings":"AAAA,SAASA,gBAAgB;;AAEzB;AACA;AACA;AACA;AACA,OAAO,MAAeC,kBAAkB,SAE9BD,gBAAgB,CAAQ","ignoreList":[]}

package/features/modelBuilder/fields/LocationFieldType.d.ts

@@ -0,0 +1,16 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { FieldBuilderRegistry } from "../abstractions.js";
+import { IObjectFieldBuilder } from "./ObjectFieldType.js";
+declare class LocationFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "location";
+    create(registry: FieldBuilderRegistry.Interface): IObjectFieldBuilder;
+}
+export declare const LocationFieldType: typeof LocationFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        location(): IObjectFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/LocationFieldType.js

@@ -0,0 +1,21 @@
+import { FieldType } from "./abstractions.js";
+import { ObjectFieldBuilder } from "./ObjectFieldType.js";
+class LocationFieldTypeFactory {
+  type = "location";
+  create(registry) {
+    const builder = new ObjectFieldBuilder(registry);
+    return builder.label("Location").fields(fields => ({
+      folderId: fields.text().label("Folder ID").settings({
+        path: "location.folderId"
+      })
+    }));
+  }
+}
+export const LocationFieldType = FieldType.createImplementation({
+  implementation: LocationFieldTypeFactory,
+  dependencies: []
+});
+
+// Module augmentation for TypeScript autocomplete
+
+//# sourceMappingURL=LocationFieldType.js.map

package/features/modelBuilder/fields/LocationFieldType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","ObjectFieldBuilder","LocationFieldTypeFactory","type","create","registry","builder","label","fields","folderId","text","settings","path","LocationFieldType","createImplementation","implementation","dependencies"],"sources":["LocationFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { FieldBuilderRegistry } from \"../abstractions.js\";\nimport { IObjectFieldBuilder, ObjectFieldBuilder } from \"./ObjectFieldType.js\";\n\nclass LocationFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"location\";\n\n    create(registry: FieldBuilderRegistry.Interface): IObjectFieldBuilder {\n        const builder = new ObjectFieldBuilder(registry);\n        return builder.label(\"Location\").fields(fields => ({\n            folderId: fields.text().label(\"Folder ID\").settings({ path: \"location.folderId\" })\n        }));\n    }\n}\n\nexport const LocationFieldType = FieldType.createImplementation({\n    implementation: LocationFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        location(): IObjectFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAElB,SAA8BC,kBAAkB;AAEhD,MAAMC,wBAAwB,CAA8B;EAC/CC,IAAI,GAAG,UAAU;EAE1BC,MAAMA,CAACC,QAAwC,EAAuB;IAClE,MAAMC,OAAO,GAAG,IAAIL,kBAAkB,CAACI,QAAQ,CAAC;IAChD,OAAOC,OAAO,CAACC,KAAK,CAAC,UAAU,CAAC,CAACC,MAAM,CAACA,MAAM,KAAK;MAC/CC,QAAQ,EAAED,MAAM,CAACE,IAAI,CAAC,CAAC,CAACH,KAAK,CAAC,WAAW,CAAC,CAACI,QAAQ,CAAC;QAAEC,IAAI,EAAE;MAAoB,CAAC;IACrF,CAAC,CAAC,CAAC;EACP;AACJ;AAEA,OAAO,MAAMC,iBAAiB,GAAGb,SAAS,CAACc,oBAAoB,CAAC;EAC5DC,cAAc,EAAEb,wBAAwB;EACxCc,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

package/features/modelBuilder/fields/LongTextFieldType.d.ts

@@ -0,0 +1,18 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+import { RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, EmailValidator, UrlValidator, LowerCaseValidator, UpperCaseValidator, LowerCaseSpaceValidator, UpperCaseSpaceValidator } from "./fieldTypeValidator.js";
+export interface ILongTextFieldBuilder extends DataFieldBuilder<"long-text">, RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, EmailValidator, UrlValidator, LowerCaseValidator, UpperCaseValidator, LowerCaseSpaceValidator, UpperCaseSpaceValidator {
+}
+declare class LongTextFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "long-text";
+    create(): ILongTextFieldBuilder;
+}
+export declare const LongTextFieldType: typeof LongTextFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        longText(): ILongTextFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/LongTextFieldType.js

@@ -0,0 +1,123 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+class LongTextFieldBuilder extends DataFieldBuilder {
+  constructor() {
+    super("long-text");
+  }
+  required(message) {
+    return this.validation({
+      name: "required",
+      message: message || "Value is required.",
+      settings: {}
+    });
+  }
+  minLength(value, message) {
+    return this.validation({
+      name: "minLength",
+      message: message || "Value is too short.",
+      settings: {
+        value: String(value)
+      }
+    });
+  }
+  maxLength(value, message) {
+    return this.validation({
+      name: "maxLength",
+      message: message || "Value is too long.",
+      settings: {
+        value: String(value)
+      }
+    });
+  }
+  pattern(regex, flags = "", message) {
+    return this.validation({
+      name: "pattern",
+      message: message || "Invalid value.",
+      settings: {
+        preset: "custom",
+        regex,
+        flags
+      }
+    });
+  }
+  email(message) {
+    return this.validation({
+      name: "pattern",
+      message: message || "Please enter a valid e-mail.",
+      settings: {
+        preset: "email",
+        regex: null,
+        flags: null
+      }
+    });
+  }
+  url(message) {
+    return this.validation({
+      name: "pattern",
+      message: message || "Please enter a valid URL.",
+      settings: {
+        preset: "url",
+        regex: null,
+        flags: null
+      }
+    });
+  }
+  lowerCase(message) {
+    return this.validation({
+      name: "pattern",
+      message: message || "Only lower case characters are allowed.",
+      settings: {
+        preset: "lowerCase",
+        regex: null,
+        flags: null
+      }
+    });
+  }
+  upperCase(message) {
+    return this.validation({
+      name: "pattern",
+      message: message || "Only upper case characters are allowed.",
+      settings: {
+        preset: "upperCase",
+        regex: null,
+        flags: null
+      }
+    });
+  }
+  lowerCaseSpace(message) {
+    return this.validation({
+      name: "pattern",
+      message: message || "Only lower case characters and space are allowed.",
+      settings: {
+        preset: "lowerCaseSpace",
+        regex: null,
+        flags: null
+      }
+    });
+  }
+  upperCaseSpace(message) {
+    return this.validation({
+      name: "pattern",
+      message: message || "Only upper case characters and space are allowed.",
+      settings: {
+        preset: "upperCaseSpace",
+        regex: null,
+        flags: null
+      }
+    });
+  }
+}
+class LongTextFieldTypeFactory {
+  type = "long-text";
+  create() {
+    return new LongTextFieldBuilder();
+  }
+}
+export const LongTextFieldType = FieldType.createImplementation({
+  implementation: LongTextFieldTypeFactory,
+  dependencies: []
+});
+
+// Module augmentation for TypeScript autocomplete
+
+//# sourceMappingURL=LongTextFieldType.js.map