@webiny/api-headless-cms 6.0.0-beta.0 → 6.0.0-rc.0

package/features/modelBuilder/fields/JsonFieldType.js

@@ -0,0 +1,21 @@
+import { FieldType } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+class JsonFieldBuilder extends FieldBuilder {
+  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","FieldBuilder","JsonFieldBuilder","constructor","JsonFieldTypeFactory","type","create","JsonFieldType","createImplementation","implementation","dependencies"],"sources":["JsonFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { FieldBuilder } from \"./FieldBuilder.js\";\n\nexport interface IJsonFieldBuilder extends FieldBuilder<\"json\"> {}\n\nclass JsonFieldBuilder extends FieldBuilder<\"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,YAAY;AAIrB,MAAMC,gBAAgB,SAASD,YAAY,CAAsC;EACtEE,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/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,19 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+import { RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, EmailValidator, UrlValidator, LowerCaseValidator, UpperCaseValidator, LowerCaseSpaceValidator, UpperCaseSpaceValidator } from "./validators.js";
+export interface ILongTextFieldBuilder extends FieldBuilder<"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 {
+        "long-text"(): ILongTextFieldBuilder;
+        longText(): ILongTextFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/LongTextFieldType.js

@@ -0,0 +1,123 @@
+import { FieldType } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+class LongTextFieldBuilder extends FieldBuilder {
+  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

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

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","FieldBuilder","LongTextFieldBuilder","constructor","required","message","validation","name","settings","minLength","value","String","maxLength","pattern","regex","flags","preset","email","url","lowerCase","upperCase","lowerCaseSpace","upperCaseSpace","LongTextFieldTypeFactory","type","create","LongTextFieldType","createImplementation","implementation","dependencies"],"sources":["LongTextFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { FieldBuilder } from \"./FieldBuilder.js\";\nimport {\n    RequiredValidator,\n    MinLengthValidator,\n    MaxLengthValidator,\n    PatternValidator,\n    EmailValidator,\n    UrlValidator,\n    LowerCaseValidator,\n    UpperCaseValidator,\n    LowerCaseSpaceValidator,\n    UpperCaseSpaceValidator\n} from \"./validators.js\";\n\nexport interface ILongTextFieldBuilder\n    extends FieldBuilder<\"long-text\">,\n        RequiredValidator,\n        MinLengthValidator,\n        MaxLengthValidator,\n        PatternValidator,\n        EmailValidator,\n        UrlValidator,\n        LowerCaseValidator,\n        UpperCaseValidator,\n        LowerCaseSpaceValidator,\n        UpperCaseSpaceValidator {}\n\nclass LongTextFieldBuilder extends FieldBuilder<\"long-text\"> implements ILongTextFieldBuilder {\n    public constructor() {\n        super(\"long-text\");\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    minLength(value: number, message?: string): this {\n        return this.validation({\n            name: \"minLength\",\n            message: message || \"Value is too short.\",\n            settings: { value: String(value) }\n        });\n    }\n\n    maxLength(value: number, message?: string): this {\n        return this.validation({\n            name: \"maxLength\",\n            message: message || \"Value is too long.\",\n            settings: { value: String(value) }\n        });\n    }\n\n    pattern(regex: string, flags: string = \"\", message?: string): this {\n        return this.validation({\n            name: \"pattern\",\n            message: message || \"Invalid value.\",\n            settings: {\n                preset: \"custom\",\n                regex,\n                flags\n            }\n        });\n    }\n\n    email(message?: string): this {\n        return this.validation({\n            name: \"pattern\",\n            message: message || \"Please enter a valid e-mail.\",\n            settings: {\n                preset: \"email\",\n                regex: null,\n                flags: null\n            }\n        });\n    }\n\n    url(message?: string): this {\n        return this.validation({\n            name: \"pattern\",\n            message: message || \"Please enter a valid URL.\",\n            settings: {\n                preset: \"url\",\n                regex: null,\n                flags: null\n            }\n        });\n    }\n\n    lowerCase(message?: string): this {\n        return this.validation({\n            name: \"pattern\",\n            message: message || \"Only lower case characters are allowed.\",\n            settings: {\n                preset: \"lowerCase\",\n                regex: null,\n                flags: null\n            }\n        });\n    }\n\n    upperCase(message?: string): this {\n        return this.validation({\n            name: \"pattern\",\n            message: message || \"Only upper case characters are allowed.\",\n            settings: {\n                preset: \"upperCase\",\n                regex: null,\n                flags: null\n            }\n        });\n    }\n\n    lowerCaseSpace(message?: string): this {\n        return this.validation({\n            name: \"pattern\",\n            message: message || \"Only lower case characters and space are allowed.\",\n            settings: {\n                preset: \"lowerCaseSpace\",\n                regex: null,\n                flags: null\n            }\n        });\n    }\n\n    upperCaseSpace(message?: string): this {\n        return this.validation({\n            name: \"pattern\",\n            message: message || \"Only upper case characters and space are allowed.\",\n            settings: {\n                preset: \"upperCaseSpace\",\n                regex: null,\n                flags: null\n            }\n        });\n    }\n}\n\nclass LongTextFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"long-text\";\n\n    create(): ILongTextFieldBuilder {\n        return new LongTextFieldBuilder();\n    }\n}\n\nexport const LongTextFieldType = FieldType.createImplementation({\n    implementation: LongTextFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        \"long-text\"(): ILongTextFieldBuilder;\n        longText(): ILongTextFieldBuilder;\n    }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,18 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+import { RequiredValidator, GteValidator, LteValidator } from "./validators.js";
+export interface INumberFieldBuilder extends FieldBuilder<"number">, RequiredValidator, GteValidator, LteValidator {
+}
+declare class NumberFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "number";
+    create(): INumberFieldBuilder;
+}
+export declare const NumberFieldType: typeof NumberFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        number(): INumberFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/NumberFieldType.js

@@ -0,0 +1,46 @@
+import { FieldType } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+class NumberFieldBuilder extends FieldBuilder {
+  constructor() {
+    super("number");
+  }
+  required(message) {
+    return this.validation({
+      name: "required",
+      message: message || "Value is required.",
+      settings: {}
+    });
+  }
+  gte(value, message) {
+    return this.validation({
+      name: "gte",
+      message: message || "Value is too small.",
+      settings: {
+        value: String(value)
+      }
+    });
+  }
+  lte(value, message) {
+    return this.validation({
+      name: "lte",
+      message: message || "Value is too large.",
+      settings: {
+        value: String(value)
+      }
+    });
+  }
+}
+class NumberFieldTypeFactory {
+  type = "number";
+  create() {
+    return new NumberFieldBuilder();
+  }
+}
+export const NumberFieldType = FieldType.createImplementation({
+  implementation: NumberFieldTypeFactory,
+  dependencies: []
+});
+
+// Module augmentation for TypeScript autocomplete
+
+//# sourceMappingURL=NumberFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","FieldBuilder","NumberFieldBuilder","constructor","required","message","validation","name","settings","gte","value","String","lte","NumberFieldTypeFactory","type","create","NumberFieldType","createImplementation","implementation","dependencies"],"sources":["NumberFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { FieldBuilder } from \"./FieldBuilder.js\";\nimport { RequiredValidator, GteValidator, LteValidator } from \"./validators.js\";\n\nexport interface INumberFieldBuilder\n    extends FieldBuilder<\"number\">,\n        RequiredValidator,\n        GteValidator,\n        LteValidator {}\n\nclass NumberFieldBuilder extends FieldBuilder<\"number\"> implements INumberFieldBuilder {\n    public constructor() {\n        super(\"number\");\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    gte(value: number, message?: string): this {\n        return this.validation({\n            name: \"gte\",\n            message: message || \"Value is too small.\",\n            settings: { value: String(value) }\n        });\n    }\n\n    lte(value: number, message?: string): this {\n        return this.validation({\n            name: \"lte\",\n            message: message || \"Value is too large.\",\n            settings: { value: String(value) }\n        });\n    }\n}\n\nclass NumberFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"number\";\n\n    create(): INumberFieldBuilder {\n        return new NumberFieldBuilder();\n    }\n}\n\nexport const NumberFieldType = FieldType.createImplementation({\n    implementation: NumberFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        number(): INumberFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAClB,SAASC,YAAY;AASrB,MAAMC,kBAAkB,SAASD,YAAY,CAA0C;EAC5EE,WAAWA,CAAA,EAAG;IACjB,KAAK,CAAC,QAAQ,CAAC;EACnB;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,GAAGA,CAACC,KAAa,EAAEL,OAAgB,EAAQ;IACvC,OAAO,IAAI,CAACC,UAAU,CAAC;MACnBC,IAAI,EAAE,KAAK;MACXF,OAAO,EAAEA,OAAO,IAAI,qBAAqB;MACzCG,QAAQ,EAAE;QAAEE,KAAK,EAAEC,MAAM,CAACD,KAAK;MAAE;IACrC,CAAC,CAAC;EACN;EAEAE,GAAGA,CAACF,KAAa,EAAEL,OAAgB,EAAQ;IACvC,OAAO,IAAI,CAACC,UAAU,CAAC;MACnBC,IAAI,EAAE,KAAK;MACXF,OAAO,EAAEA,OAAO,IAAI,qBAAqB;MACzCG,QAAQ,EAAE;QAAEE,KAAK,EAAEC,MAAM,CAACD,KAAK;MAAE;IACrC,CAAC,CAAC;EACN;AACJ;AAEA,MAAMG,sBAAsB,CAA8B;EAC7CC,IAAI,GAAG,QAAQ;EAExBC,MAAMA,CAAA,EAAwB;IAC1B,OAAO,IAAIb,kBAAkB,CAAC,CAAC;EACnC;AACJ;AAEA,OAAO,MAAMc,eAAe,GAAGhB,SAAS,CAACiB,oBAAoB,CAAC;EAC1DC,cAAc,EAAEL,sBAAsB;EACtCM,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

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

@@ -0,0 +1,32 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+import { FieldBuilderRegistry } from "../abstractions.js";
+import { LayoutBuilder } from "../LayoutBuilder.js";
+export interface IObjectFieldBuilder extends FieldBuilder<"object"> {
+    required(message?: string): this;
+    fields(builder: (registry: FieldBuilderRegistry.Interface) => Record<string, FieldBuilder<any>>): this;
+    layout(layoutOrBuilder: string[][] | ((builder: LayoutBuilder) => void)): this;
+}
+export declare class ObjectFieldBuilder extends FieldBuilder<"object"> implements IObjectFieldBuilder {
+    private registry;
+    private layoutBuilder;
+    private fieldBuildersMap;
+    constructor(registry: FieldBuilderRegistry.Interface);
+    required(message?: string): this;
+    fields(builder: (registry: FieldBuilderRegistry.Interface) => Record<string, FieldBuilder<any>>): this;
+    layout(layoutOrBuilder: string[][] | ((builder: LayoutBuilder) => void)): this;
+    build(): import("../../../types/modelField.js").CmsModelField;
+}
+declare class ObjectFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "object";
+    create(registry: FieldBuilderRegistry.Interface): IObjectFieldBuilder;
+}
+export declare const ObjectFieldType: typeof ObjectFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        object(): IObjectFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/ObjectFieldType.js

@@ -0,0 +1,65 @@
+import { FieldType } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+import { LayoutBuilder } from "../LayoutBuilder.js";
+export class ObjectFieldBuilder extends FieldBuilder {
+  fieldBuildersMap = new Map();
+  constructor(registry) {
+    super("object");
+    this.registry = registry;
+    this.layoutBuilder = new LayoutBuilder();
+  }
+  required(message) {
+    const validation = {
+      name: "required",
+      message: message || "Value is required."
+    };
+    this.config.validation = this.config.validation || [];
+    this.config.validation.push(validation);
+    return this;
+  }
+  fields(builder) {
+    // Pass existing fields to registry so it can return them when extending
+    this.registry.existingFields = this.fieldBuildersMap;
+    const fieldBuilders = builder(this.registry);
+    for (const [key, fieldBuilder] of Object.entries(fieldBuilders)) {
+      // Automatically set the fieldId from the object key
+      fieldBuilder.fieldId(key);
+      // Store builder (not built field)
+      this.fieldBuildersMap.set(key, fieldBuilder);
+    }
+    return this;
+  }
+  layout(layoutOrBuilder) {
+    if (Array.isArray(layoutOrBuilder)) {
+      // Set base layout and clear modifiers
+      this.layoutBuilder.setLayout(layoutOrBuilder);
+    } else {
+      // Queue the modifier callback
+      this.layoutBuilder.addModifier(layoutOrBuilder);
+    }
+    return this;
+  }
+  build() {
+    // Build all nested fields from field builders
+    this.config.settings = this.config.settings || {};
+    this.config.settings.fields = Array.from(this.fieldBuildersMap.values()).map(builder => builder.build());
+
+    // Build layout
+    this.config.settings.layout = this.layoutBuilder.build();
+    return super.build();
+  }
+}
+class ObjectFieldTypeFactory {
+  type = "object";
+  create(registry) {
+    return new ObjectFieldBuilder(registry);
+  }
+}
+export const ObjectFieldType = FieldType.createImplementation({
+  implementation: ObjectFieldTypeFactory,
+  dependencies: []
+});
+
+// Module augmentation for TypeScript autocomplete
+
+//# sourceMappingURL=ObjectFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","FieldBuilder","LayoutBuilder","ObjectFieldBuilder","fieldBuildersMap","Map","constructor","registry","layoutBuilder","required","message","validation","name","config","push","fields","builder","existingFields","fieldBuilders","key","fieldBuilder","Object","entries","fieldId","set","layout","layoutOrBuilder","Array","isArray","setLayout","addModifier","build","settings","from","values","map","ObjectFieldTypeFactory","type","create","ObjectFieldType","createImplementation","implementation","dependencies"],"sources":["ObjectFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { FieldBuilder } from \"./FieldBuilder.js\";\nimport { FieldBuilderRegistry } from \"../abstractions.js\";\nimport { LayoutBuilder } from \"../LayoutBuilder.js\";\n\nexport interface IObjectFieldBuilder extends FieldBuilder<\"object\"> {\n    required(message?: string): this;\n    fields(\n        builder: (registry: FieldBuilderRegistry.Interface) => Record<string, FieldBuilder<any>>\n    ): this;\n    layout(layoutOrBuilder: string[][] | ((builder: LayoutBuilder) => void)): this;\n}\n\nexport class ObjectFieldBuilder extends FieldBuilder<\"object\"> implements IObjectFieldBuilder {\n    private layoutBuilder: LayoutBuilder;\n    private fieldBuildersMap = new Map<string, FieldBuilder<any>>();\n\n    public constructor(private registry: FieldBuilderRegistry.Interface) {\n        super(\"object\");\n        this.layoutBuilder = new LayoutBuilder();\n    }\n\n    required(message?: string): this {\n        const validation = {\n            name: \"required\",\n            message: message || \"Value is required.\"\n        };\n        this.config.validation = this.config.validation || [];\n        this.config.validation.push(validation);\n        return this;\n    }\n\n    fields(\n        builder: (registry: FieldBuilderRegistry.Interface) => Record<string, FieldBuilder<any>>\n    ): this {\n        // Pass existing fields to registry so it can return them when extending\n        (this.registry as any).existingFields = this.fieldBuildersMap;\n\n        const fieldBuilders = builder(this.registry);\n        for (const [key, fieldBuilder] of Object.entries(fieldBuilders)) {\n            // Automatically set the fieldId from the object key\n            fieldBuilder.fieldId(key);\n            // Store builder (not built field)\n            this.fieldBuildersMap.set(key, fieldBuilder);\n        }\n\n        return this;\n    }\n\n    layout(layoutOrBuilder: string[][] | ((builder: LayoutBuilder) => void)): this {\n        if (Array.isArray(layoutOrBuilder)) {\n            // Set base layout and clear modifiers\n            this.layoutBuilder.setLayout(layoutOrBuilder);\n        } else {\n            // Queue the modifier callback\n            this.layoutBuilder.addModifier(layoutOrBuilder);\n        }\n\n        return this;\n    }\n\n    override build() {\n        // Build all nested fields from field builders\n        this.config.settings = this.config.settings || {};\n        this.config.settings.fields = Array.from(this.fieldBuildersMap.values()).map(builder =>\n            builder.build()\n        );\n\n        // Build layout\n        this.config.settings.layout = this.layoutBuilder.build();\n\n        return super.build();\n    }\n}\n\nclass ObjectFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"object\";\n\n    create(registry: FieldBuilderRegistry.Interface): IObjectFieldBuilder {\n        return new ObjectFieldBuilder(registry);\n    }\n}\n\nexport const ObjectFieldType = FieldType.createImplementation({\n    implementation: ObjectFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        object(): IObjectFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAClB,SAASC,YAAY;AAErB,SAASC,aAAa;AAUtB,OAAO,MAAMC,kBAAkB,SAASF,YAAY,CAA0C;EAElFG,gBAAgB,GAAG,IAAIC,GAAG,CAA4B,CAAC;EAExDC,WAAWA,CAASC,QAAwC,EAAE;IACjE,KAAK,CAAC,QAAQ,CAAC;IAAC,KADOA,QAAwC,GAAxCA,QAAwC;IAE/D,IAAI,CAACC,aAAa,GAAG,IAAIN,aAAa,CAAC,CAAC;EAC5C;EAEAO,QAAQA,CAACC,OAAgB,EAAQ;IAC7B,MAAMC,UAAU,GAAG;MACfC,IAAI,EAAE,UAAU;MAChBF,OAAO,EAAEA,OAAO,IAAI;IACxB,CAAC;IACD,IAAI,CAACG,MAAM,CAACF,UAAU,GAAG,IAAI,CAACE,MAAM,CAACF,UAAU,IAAI,EAAE;IACrD,IAAI,CAACE,MAAM,CAACF,UAAU,CAACG,IAAI,CAACH,UAAU,CAAC;IACvC,OAAO,IAAI;EACf;EAEAI,MAAMA,CACFC,OAAwF,EACpF;IACJ;IACC,IAAI,CAACT,QAAQ,CAASU,cAAc,GAAG,IAAI,CAACb,gBAAgB;IAE7D,MAAMc,aAAa,GAAGF,OAAO,CAAC,IAAI,CAACT,QAAQ,CAAC;IAC5C,KAAK,MAAM,CAACY,GAAG,EAAEC,YAAY,CAAC,IAAIC,MAAM,CAACC,OAAO,CAACJ,aAAa,CAAC,EAAE;MAC7D;MACAE,YAAY,CAACG,OAAO,CAACJ,GAAG,CAAC;MACzB;MACA,IAAI,CAACf,gBAAgB,CAACoB,GAAG,CAACL,GAAG,EAAEC,YAAY,CAAC;IAChD;IAEA,OAAO,IAAI;EACf;EAEAK,MAAMA,CAACC,eAAgE,EAAQ;IAC3E,IAAIC,KAAK,CAACC,OAAO,CAACF,eAAe,CAAC,EAAE;MAChC;MACA,IAAI,CAAClB,aAAa,CAACqB,SAAS,CAACH,eAAe,CAAC;IACjD,CAAC,MAAM;MACH;MACA,IAAI,CAAClB,aAAa,CAACsB,WAAW,CAACJ,eAAe,CAAC;IACnD;IAEA,OAAO,IAAI;EACf;EAESK,KAAKA,CAAA,EAAG;IACb;IACA,IAAI,CAAClB,MAAM,CAACmB,QAAQ,GAAG,IAAI,CAACnB,MAAM,CAACmB,QAAQ,IAAI,CAAC,CAAC;IACjD,IAAI,CAACnB,MAAM,CAACmB,QAAQ,CAACjB,MAAM,GAAGY,KAAK,CAACM,IAAI,CAAC,IAAI,CAAC7B,gBAAgB,CAAC8B,MAAM,CAAC,CAAC,CAAC,CAACC,GAAG,CAACnB,OAAO,IAChFA,OAAO,CAACe,KAAK,CAAC,CAClB,CAAC;;IAED;IACA,IAAI,CAAClB,MAAM,CAACmB,QAAQ,CAACP,MAAM,GAAG,IAAI,CAACjB,aAAa,CAACuB,KAAK,CAAC,CAAC;IAExD,OAAO,KAAK,CAACA,KAAK,CAAC,CAAC;EACxB;AACJ;AAEA,MAAMK,sBAAsB,CAA8B;EAC7CC,IAAI,GAAG,QAAQ;EAExBC,MAAMA,CAAC/B,QAAwC,EAAuB;IAClE,OAAO,IAAIJ,kBAAkB,CAACI,QAAQ,CAAC;EAC3C;AACJ;AAEA,OAAO,MAAMgC,eAAe,GAAGvC,SAAS,CAACwC,oBAAoB,CAAC;EAC1DC,cAAc,EAAEL,sBAAsB;EACtCM,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

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

@@ -0,0 +1,21 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+import { RequiredValidator, ListMinLengthValidator, ListMaxLengthValidator } from "./validators.js";
+export interface IRefFieldBuilder extends FieldBuilder<"ref">, RequiredValidator, ListMinLengthValidator, ListMaxLengthValidator {
+    models(models: Array<{
+        modelId: string;
+    }>): this;
+}
+declare class RefFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "ref";
+    create(): IRefFieldBuilder;
+}
+export declare const RefFieldType: typeof RefFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        ref(): IRefFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/RefFieldType.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","FieldBuilder","RefFieldBuilder","constructor","required","message","validation","name","settings","models","config","RefFieldTypeFactory","type","create","RefFieldType","createImplementation","implementation","dependencies"],"sources":["RefFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { FieldBuilder } from \"./FieldBuilder.js\";\nimport { RequiredValidator, ListMinLengthValidator, ListMaxLengthValidator } from \"./validators.js\";\n\nexport interface IRefFieldBuilder\n    extends FieldBuilder<\"ref\">,\n        RequiredValidator,\n        ListMinLengthValidator,\n        ListMaxLengthValidator {\n    models(models: Array<{ modelId: string }>): this;\n}\n\nclass RefFieldBuilder extends FieldBuilder<\"ref\"> implements IRefFieldBuilder {\n    public constructor() {\n        super(\"ref\");\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    models(models: Array<{ modelId: string }>): this {\n        this.config.settings = this.config.settings || {};\n        this.config.settings.models = models;\n        return this;\n    }\n}\n\nclass RefFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"ref\";\n\n    create(): IRefFieldBuilder {\n        return new RefFieldBuilder();\n    }\n}\n\nexport const RefFieldType = FieldType.createImplementation({\n    implementation: RefFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        ref(): IRefFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAClB,SAASC,YAAY;AAWrB,MAAMC,eAAe,SAASD,YAAY,CAAoC;EACnEE,WAAWA,CAAA,EAAG;IACjB,KAAK,CAAC,KAAK,CAAC;EAChB;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,MAAMA,CAACA,MAAkC,EAAQ;IAC7C,IAAI,CAACC,MAAM,CAACF,QAAQ,GAAG,IAAI,CAACE,MAAM,CAACF,QAAQ,IAAI,CAAC,CAAC;IACjD,IAAI,CAACE,MAAM,CAACF,QAAQ,CAACC,MAAM,GAAGA,MAAM;IACpC,OAAO,IAAI;EACf;AACJ;AAEA,MAAME,mBAAmB,CAA8B;EAC1CC,IAAI,GAAG,KAAK;EAErBC,MAAMA,CAAA,EAAqB;IACvB,OAAO,IAAIX,eAAe,CAAC,CAAC;EAChC;AACJ;AAEA,OAAO,MAAMY,YAAY,GAAGd,SAAS,CAACe,oBAAoB,CAAC;EACvDC,cAAc,EAAEL,mBAAmB;EACnCM,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

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

@@ -0,0 +1,19 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+export interface IRichTextFieldBuilder extends FieldBuilder<"rich-text"> {
+    required(message?: string): this;
+}
+declare class RichTextFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "rich-text";
+    create(): IRichTextFieldBuilder;
+}
+export declare const RichTextFieldType: typeof RichTextFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        "rich-text"(): IRichTextFieldBuilder;
+        richText(): IRichTextFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/RichTextFieldType.js

@@ -0,0 +1,28 @@
+import { FieldType } from "./abstractions.js";
+import { FieldBuilder } from "./FieldBuilder.js";
+class RichTextFieldBuilder extends FieldBuilder {
+  constructor() {
+    super("rich-text");
+  }
+  required(message) {
+    return this.validation({
+      name: "required",
+      message: message || "Field is required",
+      settings: {}
+    });
+  }
+}
+class RichTextFieldTypeFactory {
+  type = "rich-text";
+  create() {
+    return new RichTextFieldBuilder();
+  }
+}
+export const RichTextFieldType = FieldType.createImplementation({
+  implementation: RichTextFieldTypeFactory,
+  dependencies: []
+});
+
+// Module augmentation for TypeScript autocomplete
+
+//# sourceMappingURL=RichTextFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","FieldBuilder","RichTextFieldBuilder","constructor","required","message","validation","name","settings","RichTextFieldTypeFactory","type","create","RichTextFieldType","createImplementation","implementation","dependencies"],"sources":["RichTextFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { FieldBuilder } from \"./FieldBuilder.js\";\n\nexport interface IRichTextFieldBuilder extends FieldBuilder<\"rich-text\"> {\n    required(message?: string): this;\n}\n\nclass RichTextFieldBuilder extends FieldBuilder<\"rich-text\"> implements IRichTextFieldBuilder {\n    public constructor() {\n        super(\"rich-text\");\n    }\n\n    required(message?: string): this {\n        return this.validation({\n            name: \"required\",\n            message: message || \"Field is required\",\n            settings: {}\n        });\n    }\n}\n\nclass RichTextFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"rich-text\";\n\n    create(): IRichTextFieldBuilder {\n        return new RichTextFieldBuilder();\n    }\n}\n\nexport const RichTextFieldType = FieldType.createImplementation({\n    implementation: RichTextFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        \"rich-text\"(): IRichTextFieldBuilder;\n        richText(): IRichTextFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAClB,SAASC,YAAY;AAMrB,MAAMC,oBAAoB,SAASD,YAAY,CAA+C;EACnFE,WAAWA,CAAA,EAAG;IACjB,KAAK,CAAC,WAAW,CAAC;EACtB;EAEAC,QAAQA,CAACC,OAAgB,EAAQ;IAC7B,OAAO,IAAI,CAACC,UAAU,CAAC;MACnBC,IAAI,EAAE,UAAU;MAChBF,OAAO,EAAEA,OAAO,IAAI,mBAAmB;MACvCG,QAAQ,EAAE,CAAC;IACf,CAAC,CAAC;EACN;AACJ;AAEA,MAAMC,wBAAwB,CAA8B;EAC/CC,IAAI,GAAG,WAAW;EAE3BC,MAAMA,CAAA,EAA0B;IAC5B,OAAO,IAAIT,oBAAoB,CAAC,CAAC;EACrC;AACJ;AAEA,OAAO,MAAMU,iBAAiB,GAAGZ,SAAS,CAACa,oBAAoB,CAAC;EAC5DC,cAAc,EAAEL,wBAAwB;EACxCM,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

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

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

package/features/modelBuilder/fields/SearchableJsonFieldType.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["FieldType","FieldBuilder","SearchableJsonFieldBuilder","constructor","SearchableJsonFieldTypeFactory","type","create","SearchableJsonFieldType","createImplementation","implementation","dependencies"],"sources":["SearchableJsonFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { FieldBuilder } from \"./FieldBuilder.js\";\n\nexport interface ISearchableJsonFieldBuilder extends FieldBuilder<\"searchable-json\"> {}\n\nclass SearchableJsonFieldBuilder\n    extends FieldBuilder<\"searchable-json\">\n    implements ISearchableJsonFieldBuilder\n{\n    public constructor() {\n        super(\"searchable-json\");\n    }\n}\n\nclass SearchableJsonFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"searchable-json\";\n\n    create(): ISearchableJsonFieldBuilder {\n        return new SearchableJsonFieldBuilder();\n    }\n}\n\nexport const SearchableJsonFieldType = FieldType.createImplementation({\n    implementation: SearchableJsonFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        searchableJson(): ISearchableJsonFieldBuilder;\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS;AAClB,SAASC,YAAY;AAIrB,MAAMC,0BAA0B,SACpBD,YAAY,CAExB;EACWE,WAAWA,CAAA,EAAG;IACjB,KAAK,CAAC,iBAAiB,CAAC;EAC5B;AACJ;AAEA,MAAMC,8BAA8B,CAA8B;EACrDC,IAAI,GAAG,iBAAiB;EAEjCC,MAAMA,CAAA,EAAgC;IAClC,OAAO,IAAIJ,0BAA0B,CAAC,CAAC;EAC3C;AACJ;AAEA,OAAO,MAAMK,uBAAuB,GAAGP,SAAS,CAACQ,oBAAoB,CAAC;EAClEC,cAAc,EAAEL,8BAA8B;EAC9CM,YAAY,EAAE;AAClB,CAAC,CAAC;;AAEF","ignoreList":[]}

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

@@ -0,0 +1,16 @@
+import { FieldBuilder } from "./FieldBuilder.js";
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, EmailValidator, UrlValidator, LowerCaseValidator, UpperCaseValidator, LowerCaseSpaceValidator, UpperCaseSpaceValidator, UniqueValidator } from "./validators.js";
+export interface ITextFieldBuilder extends FieldBuilder<"text">, RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, EmailValidator, UrlValidator, LowerCaseValidator, UpperCaseValidator, LowerCaseSpaceValidator, UpperCaseSpaceValidator, UniqueValidator {
+}
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        text(): ITextFieldBuilder;
+    }
+}
+declare class TextFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "text";
+    create(): ITextFieldBuilder;
+}
+export declare const TextFieldType: import("@webiny/di").Implementation<typeof TextFieldTypeFactory>;
+export {};