@webiny/api-headless-cms 0.0.0-unstable.06b2ede40f → 0.0.0-unstable.0d717d18dd

package/features/modelBuilder/fields/ObjectFieldType.js

@@ -0,0 +1,63 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+import { LayoutBuilder } from "../LayoutBuilder.js";
+class ObjectFieldBuilder extends DataFieldBuilder {
+    constructor(registry){
+        super("object"), this.registry = registry, this.fieldBuildersMap = new Map();
+        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) {
+        this.registry.existingFields = this.fieldBuildersMap;
+        const fieldBuilders = builder(this.registry);
+        for (const [key, fieldBuilder] of Object.entries(fieldBuilders)){
+            fieldBuilder.fieldId(key);
+            this.fieldBuildersMap.set(key, fieldBuilder);
+        }
+        return this;
+    }
+    layout(layoutOrBuilder) {
+        if (Array.isArray(layoutOrBuilder)) this.layoutBuilder.setLayout(layoutOrBuilder);
+        else this.layoutBuilder.addModifier(layoutOrBuilder);
+        return this;
+    }
+    build() {
+        this.config.settings = this.config.settings || {};
+        const fields = [];
+        const layoutReplacements = new Map();
+        for (const [fieldId, builder] of this.fieldBuildersMap){
+            const result = builder.build();
+            if ("layout" === result.type) {
+                layoutReplacements.set(fieldId, result.layoutCell);
+                if (result.fields) fields.push(...result.fields);
+            } else fields.push(result.field);
+        }
+        this.config.settings.fields = fields;
+        const rawLayout = this.layoutBuilder.build();
+        this.config.settings.layout = rawLayout.map((row)=>row.map((cell)=>layoutReplacements.get(cell) ?? cell));
+        return super.build();
+    }
+}
+class ObjectFieldTypeFactory {
+    create(registry) {
+        return new ObjectFieldBuilder(registry);
+    }
+    constructor(){
+        this.type = "object";
+    }
+}
+const ObjectFieldType = FieldType.createImplementation({
+    implementation: ObjectFieldTypeFactory,
+    dependencies: []
+});
+export { ObjectFieldBuilder, ObjectFieldType };
+
+//# sourceMappingURL=ObjectFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/ObjectFieldType.js","sources":["../../../../src/features/modelBuilder/fields/ObjectFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { BaseFieldBuilder } from \"./BaseFieldBuilder.js\";\nimport { DataFieldBuilder } from \"./FieldBuilder.js\";\nimport { FieldBuilderRegistry } from \"../abstractions.js\";\nimport { LayoutBuilder } from \"../LayoutBuilder.js\";\nimport type { CmsModelField, CmsModelLayoutCell } from \"~/types/index.js\";\n\nexport interface IObjectFieldBuilder extends DataFieldBuilder<\"object\"> {\n    required(message?: string): this;\n    fields(\n        builder: (registry: FieldBuilderRegistry.Interface) => Record<string, BaseFieldBuilder<any>>\n    ): this;\n    layout(layoutOrBuilder: string[][] | ((builder: LayoutBuilder) => void)): this;\n}\n\nexport class ObjectFieldBuilder extends DataFieldBuilder<\"object\"> implements IObjectFieldBuilder {\n    private layoutBuilder: LayoutBuilder;\n    private fieldBuildersMap = new Map<string, BaseFieldBuilder<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, BaseFieldBuilder<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        this.config.settings = this.config.settings || {};\n\n        // Build nested fields, separating data fields from layout fields\n        const fields: CmsModelField[] = [];\n        const layoutReplacements = new Map<string, CmsModelLayoutCell>();\n\n        for (const [fieldId, builder] of this.fieldBuildersMap) {\n            const result = builder.build();\n            if (result.type === \"layout\") {\n                layoutReplacements.set(fieldId, result.layoutCell);\n                if (result.fields) {\n                    fields.push(...result.fields);\n                }\n            } else {\n                fields.push(result.field);\n            }\n        }\n\n        this.config.settings.fields = fields;\n\n        // Build layout and apply replacements\n        const rawLayout = this.layoutBuilder.build();\n        this.config.settings.layout = rawLayout.map(row =>\n            row.map(cell => layoutReplacements.get(cell) ?? cell)\n        );\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"],"names":["ObjectFieldBuilder","DataFieldBuilder","registry","Map","LayoutBuilder","message","validation","builder","fieldBuilders","key","fieldBuilder","Object","layoutOrBuilder","Array","fields","layoutReplacements","fieldId","result","rawLayout","row","cell","ObjectFieldTypeFactory","ObjectFieldType","FieldType"],"mappings":";;;AAeO,MAAMA,2BAA2BC;IAIpC,YAA2BC,QAAwC,CAAE;QACjE,KAAK,CAAC,gBADiBA,QAAQ,GAARA,UAAAA,IAAAA,CAFnB,gBAAgB,GAAG,IAAIC;QAI3B,IAAI,CAAC,aAAa,GAAG,IAAIC;IAC7B;IAEA,SAASC,OAAgB,EAAQ;QAC7B,MAAMC,aAAa;YACf,MAAM;YACN,SAASD,WAAW;QACxB;QACA,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE;QACrD,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAACC;QAC5B,OAAO,IAAI;IACf;IAEA,OACIC,OAA4F,EACxF;QAEH,IAAI,CAAC,QAAQ,CAAS,cAAc,GAAG,IAAI,CAAC,gBAAgB;QAE7D,MAAMC,gBAAgBD,QAAQ,IAAI,CAAC,QAAQ;QAC3C,KAAK,MAAM,CAACE,KAAKC,aAAa,IAAIC,OAAO,OAAO,CAACH,eAAgB;YAE7DE,aAAa,OAAO,CAACD;YAErB,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAACA,KAAKC;QACnC;QAEA,OAAO,IAAI;IACf;IAEA,OAAOE,eAAgE,EAAQ;QAC3E,IAAIC,MAAM,OAAO,CAACD,kBAEd,IAAI,CAAC,aAAa,CAAC,SAAS,CAACA;aAG7B,IAAI,CAAC,aAAa,CAAC,WAAW,CAACA;QAGnC,OAAO,IAAI;IACf;IAES,QAAQ;QACb,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC;QAGhD,MAAME,SAA0B,EAAE;QAClC,MAAMC,qBAAqB,IAAIZ;QAE/B,KAAK,MAAM,CAACa,SAAST,QAAQ,IAAI,IAAI,CAAC,gBAAgB,CAAE;YACpD,MAAMU,SAASV,QAAQ,KAAK;YAC5B,IAAIU,AAAgB,aAAhBA,OAAO,IAAI,EAAe;gBAC1BF,mBAAmB,GAAG,CAACC,SAASC,OAAO,UAAU;gBACjD,IAAIA,OAAO,MAAM,EACbH,OAAO,IAAI,IAAIG,OAAO,MAAM;YAEpC,OACIH,OAAO,IAAI,CAACG,OAAO,KAAK;QAEhC;QAEA,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAGH;QAG9B,MAAMI,YAAY,IAAI,CAAC,aAAa,CAAC,KAAK;QAC1C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAGA,UAAU,GAAG,CAACC,CAAAA,MACxCA,IAAI,GAAG,CAACC,CAAAA,OAAQL,mBAAmB,GAAG,CAACK,SAASA;QAGpD,OAAO,KAAK,CAAC;IACjB;AACJ;AAEA,MAAMC;IAGF,OAAOnB,QAAwC,EAAuB;QAClE,OAAO,IAAIF,mBAAmBE;IAClC;;aAJS,IAAI,GAAG;;AAKpB;AAEO,MAAMoB,kBAAkBC,UAAU,oBAAoB,CAAC;IAC1D,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,21 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+import type { FieldTypeValidator } from "./fieldTypeValidator.js";
+export interface IRefFieldBuilder extends DataFieldBuilder<"ref">, FieldTypeValidator.Required, FieldTypeValidator.ListMinLength, FieldTypeValidator.ListMaxLength {
+    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,34 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+class RefFieldBuilder extends DataFieldBuilder {
+    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 {
+    create() {
+        return new RefFieldBuilder();
+    }
+    constructor(){
+        this.type = "ref";
+    }
+}
+const RefFieldType = FieldType.createImplementation({
+    implementation: RefFieldTypeFactory,
+    dependencies: []
+});
+export { RefFieldType };
+
+//# sourceMappingURL=RefFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/RefFieldType.js","sources":["../../../../src/features/modelBuilder/fields/RefFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { DataFieldBuilder } from \"./FieldBuilder.js\";\nimport type { FieldTypeValidator } from \"./fieldTypeValidator.js\";\n\nexport interface IRefFieldBuilder\n    extends\n        DataFieldBuilder<\"ref\">,\n        FieldTypeValidator.Required,\n        FieldTypeValidator.ListMinLength,\n        FieldTypeValidator.ListMaxLength {\n    models(models: Array<{ modelId: string }>): this;\n}\n\nclass RefFieldBuilder extends DataFieldBuilder<\"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"],"names":["RefFieldBuilder","DataFieldBuilder","message","models","RefFieldTypeFactory","RefFieldType","FieldType"],"mappings":";;AAaA,MAAMA,wBAAwBC;IAC1B,aAAqB;QACjB,KAAK,CAAC;IACV;IAEA,SAASC,OAAgB,EAAQ;QAC7B,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU,CAAC;QACf;IACJ;IAEA,OAAOC,MAAkC,EAAQ;QAC7C,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC;QAChD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAGA;QAC9B,OAAO,IAAI;IACf;AACJ;AAEA,MAAMC;IAGF,SAA2B;QACvB,OAAO,IAAIJ;IACf;;aAJS,IAAI,GAAG;;AAKpB;AAEO,MAAMK,eAAeC,UAAU,oBAAoB,CAAC;IACvD,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,19 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+export interface IRichTextFieldBuilder extends DataFieldBuilder<"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,29 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+class RichTextFieldBuilder extends DataFieldBuilder {
+    constructor(){
+        super("rich-text");
+    }
+    required(message) {
+        return this.validation({
+            name: "required",
+            message: message || "Field is required",
+            settings: {}
+        });
+    }
+}
+class RichTextFieldTypeFactory {
+    create() {
+        return new RichTextFieldBuilder();
+    }
+    constructor(){
+        this.type = "rich-text";
+    }
+}
+const RichTextFieldType = FieldType.createImplementation({
+    implementation: RichTextFieldTypeFactory,
+    dependencies: []
+});
+export { RichTextFieldType };
+
+//# sourceMappingURL=RichTextFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/RichTextFieldType.js","sources":["../../../../src/features/modelBuilder/fields/RichTextFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { DataFieldBuilder } from \"./FieldBuilder.js\";\n\nexport interface IRichTextFieldBuilder extends DataFieldBuilder<\"rich-text\"> {\n    required(message?: string): this;\n}\n\nclass RichTextFieldBuilder extends DataFieldBuilder<\"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"],"names":["RichTextFieldBuilder","DataFieldBuilder","message","RichTextFieldTypeFactory","RichTextFieldType","FieldType"],"mappings":";;AAOA,MAAMA,6BAA6BC;IAC/B,aAAqB;QACjB,KAAK,CAAC;IACV;IAEA,SAASC,OAAgB,EAAQ;QAC7B,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU,CAAC;QACf;IACJ;AACJ;AAEA,MAAMC;IAGF,SAAgC;QAC5B,OAAO,IAAIH;IACf;;aAJS,IAAI,GAAG;;AAKpB;AAEO,MAAMI,oBAAoBC,UAAU,oBAAoB,CAAC;IAC5D,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,17 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+export interface ISearchableJsonFieldBuilder extends DataFieldBuilder<"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,22 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+class SearchableJsonFieldBuilder extends DataFieldBuilder {
+    constructor(){
+        super("searchable-json");
+    }
+}
+class SearchableJsonFieldTypeFactory {
+    create() {
+        return new SearchableJsonFieldBuilder();
+    }
+    constructor(){
+        this.type = "searchable-json";
+    }
+}
+const SearchableJsonFieldType = FieldType.createImplementation({
+    implementation: SearchableJsonFieldTypeFactory,
+    dependencies: []
+});
+export { SearchableJsonFieldType };
+
+//# sourceMappingURL=SearchableJsonFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/SearchableJsonFieldType.js","sources":["../../../../src/features/modelBuilder/fields/SearchableJsonFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { DataFieldBuilder } from \"./FieldBuilder.js\";\n\nexport interface ISearchableJsonFieldBuilder extends DataFieldBuilder<\"searchable-json\"> {}\n\nclass SearchableJsonFieldBuilder\n    extends DataFieldBuilder<\"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"],"names":["SearchableJsonFieldBuilder","DataFieldBuilder","SearchableJsonFieldTypeFactory","SearchableJsonFieldType","FieldType"],"mappings":";;AAKA,MAAMA,mCACMC;IAGR,aAAqB;QACjB,KAAK,CAAC;IACV;AACJ;AAEA,MAAMC;IAGF,SAAsC;QAClC,OAAO,IAAIF;IACf;;aAJS,IAAI,GAAG;;AAKpB;AAEO,MAAMG,0BAA0BC,UAAU,oBAAoB,CAAC;IAClE,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,29 @@
+import { DataFieldBuilder } from "./FieldBuilder.js";
+import { type IFieldTypeFactory } from "./abstractions.js";
+import type { FieldTypeValidator } from "./fieldTypeValidator.js";
+export declare enum TextFieldSubTypes {
+    COMPRESSED = "compressed",
+    ENCRYPTED = "encrypted"
+}
+export declare enum TextFieldTypes {
+    TEXT = "text",
+    COMPRESSED = "text:compressed",
+    ENCRYPTED = "text:encrypted"
+}
+export interface ITextFieldBuilder extends DataFieldBuilder<"text">, FieldTypeValidator.Required, FieldTypeValidator.MinLength, FieldTypeValidator.MaxLength, FieldTypeValidator.Pattern, FieldTypeValidator.Email, FieldTypeValidator.Url, FieldTypeValidator.LowerCase, FieldTypeValidator.UpperCase, FieldTypeValidator.LowerCaseSpace, FieldTypeValidator.UpperCaseSpace, FieldTypeValidator.Unique {
+    compress(): this;
+    encrypt(): this;
+}
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        text(): ITextFieldBuilder;
+    }
+}
+declare class TextFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "text";
+    create(): ITextFieldBuilder;
+}
+export declare const TextFieldType: typeof TextFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+export {};

package/features/modelBuilder/fields/TextFieldType.js

@@ -0,0 +1,156 @@
+import { DataFieldBuilder } from "./FieldBuilder.js";
+import { FieldType } from "./abstractions.js";
+var TextFieldType_TextFieldSubTypes = /*#__PURE__*/ function(TextFieldSubTypes) {
+    TextFieldSubTypes["COMPRESSED"] = "compressed";
+    TextFieldSubTypes["ENCRYPTED"] = "encrypted";
+    return TextFieldSubTypes;
+}({});
+var TextFieldType_TextFieldTypes = /*#__PURE__*/ function(TextFieldTypes) {
+    TextFieldTypes["TEXT"] = "text";
+    TextFieldTypes["COMPRESSED"] = "text:compressed";
+    TextFieldTypes["ENCRYPTED"] = "text:encrypted";
+    return TextFieldTypes;
+}({});
+class TextFieldBuilder extends DataFieldBuilder {
+    constructor(){
+        super("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
+            }
+        });
+    }
+    unique(message) {
+        return this.validation({
+            name: "unique",
+            message: message || "Value must be unique.",
+            settings: {}
+        });
+    }
+    compress() {
+        this.setSubType("compressed");
+        this.settings({
+            disableFullTextSearch: true
+        });
+        return this;
+    }
+    encrypt() {
+        this.setSubType("encrypted");
+        this.settings({
+            disableFullTextSearch: true
+        });
+        return this;
+    }
+}
+class TextFieldTypeFactory {
+    create() {
+        return new TextFieldBuilder();
+    }
+    constructor(){
+        this.type = "text";
+    }
+}
+const TextFieldType = FieldType.createImplementation({
+    implementation: TextFieldTypeFactory,
+    dependencies: []
+});
+export { TextFieldType, TextFieldType_TextFieldSubTypes as TextFieldSubTypes, TextFieldType_TextFieldTypes as TextFieldTypes };
+
+//# sourceMappingURL=TextFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/TextFieldType.js","sources":["../../../../src/features/modelBuilder/fields/TextFieldType.ts"],"sourcesContent":["import { DataFieldBuilder } from \"./FieldBuilder.js\";\nimport { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport type { FieldTypeValidator } from \"./fieldTypeValidator.js\";\n\nexport enum TextFieldSubTypes {\n    COMPRESSED = \"compressed\",\n    ENCRYPTED = \"encrypted\"\n}\n\nexport enum TextFieldTypes {\n    TEXT = \"text\",\n    COMPRESSED = \"text:compressed\",\n    ENCRYPTED = \"text:encrypted\"\n}\n\nexport interface ITextFieldBuilder\n    extends\n        DataFieldBuilder<\"text\">,\n        FieldTypeValidator.Required,\n        FieldTypeValidator.MinLength,\n        FieldTypeValidator.MaxLength,\n        FieldTypeValidator.Pattern,\n        FieldTypeValidator.Email,\n        FieldTypeValidator.Url,\n        FieldTypeValidator.LowerCase,\n        FieldTypeValidator.UpperCase,\n        FieldTypeValidator.LowerCaseSpace,\n        FieldTypeValidator.UpperCaseSpace,\n        FieldTypeValidator.Unique {\n    compress(): this;\n    encrypt(): this;\n}\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        text(): ITextFieldBuilder;\n    }\n}\n\nclass TextFieldBuilder extends DataFieldBuilder<\"text\"> implements ITextFieldBuilder {\n    public constructor() {\n        super(\"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    unique(message?: string): this {\n        return this.validation({\n            name: \"unique\",\n            message: message || \"Value must be unique.\",\n            settings: {}\n        });\n    }\n\n    public compress(): this {\n        this.setSubType(TextFieldSubTypes.COMPRESSED);\n\n        this.settings({\n            disableFullTextSearch: true\n        });\n\n        return this;\n    }\n    public encrypt(): this {\n        this.setSubType(TextFieldSubTypes.ENCRYPTED);\n\n        this.settings({\n            disableFullTextSearch: true\n        });\n\n        return this;\n    }\n}\n\nclass TextFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"text\";\n\n    create(): ITextFieldBuilder {\n        return new TextFieldBuilder();\n    }\n}\n\nexport const TextFieldType = FieldType.createImplementation({\n    implementation: TextFieldTypeFactory,\n    dependencies: []\n});\n"],"names":["TextFieldSubTypes","TextFieldTypes","TextFieldBuilder","DataFieldBuilder","message","value","String","regex","flags","TextFieldTypeFactory","TextFieldType","FieldType"],"mappings":";;AAIO,IAAKA,kCAAiBA,WAAAA,GAAAA,SAAjBA,iBAAiB;;;WAAjBA;;AAKL,IAAKC,+BAAcA,WAAAA,GAAAA,SAAdA,cAAc;;;;WAAdA;;AA+BZ,MAAMC,yBAAyBC;IAC3B,aAAqB;QACjB,KAAK,CAAC;IACV;IAEA,SAASC,OAAgB,EAAQ;QAC7B,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU,CAAC;QACf;IACJ;IAEA,UAAUC,KAAa,EAAED,OAAgB,EAAQ;QAC7C,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU;gBAAE,OAAOE,OAAOD;YAAO;QACrC;IACJ;IAEA,UAAUA,KAAa,EAAED,OAAgB,EAAQ;QAC7C,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU;gBAAE,OAAOE,OAAOD;YAAO;QACrC;IACJ;IAEA,QAAQE,KAAa,EAAEC,QAAgB,EAAE,EAAEJ,OAAgB,EAAQ;QAC/D,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU;gBACN,QAAQ;gBACRG;gBACAC;YACJ;QACJ;IACJ;IAEA,MAAMJ,OAAgB,EAAQ;QAC1B,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU;gBACN,QAAQ;gBACR,OAAO;gBACP,OAAO;YACX;QACJ;IACJ;IAEA,IAAIA,OAAgB,EAAQ;QACxB,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU;gBACN,QAAQ;gBACR,OAAO;gBACP,OAAO;YACX;QACJ;IACJ;IAEA,UAAUA,OAAgB,EAAQ;QAC9B,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU;gBACN,QAAQ;gBACR,OAAO;gBACP,OAAO;YACX;QACJ;IACJ;IAEA,UAAUA,OAAgB,EAAQ;QAC9B,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU;gBACN,QAAQ;gBACR,OAAO;gBACP,OAAO;YACX;QACJ;IACJ;IAEA,eAAeA,OAAgB,EAAQ;QACnC,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU;gBACN,QAAQ;gBACR,OAAO;gBACP,OAAO;YACX;QACJ;IACJ;IAEA,eAAeA,OAAgB,EAAQ;QACnC,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU;gBACN,QAAQ;gBACR,OAAO;gBACP,OAAO;YACX;QACJ;IACJ;IAEA,OAAOA,OAAgB,EAAQ;QAC3B,OAAO,IAAI,CAAC,UAAU,CAAC;YACnB,MAAM;YACN,SAASA,WAAW;YACpB,UAAU,CAAC;QACf;IACJ;IAEO,WAAiB;QACpB,IAAI,CAAC,UAAU,CAAC;QAEhB,IAAI,CAAC,QAAQ,CAAC;YACV,uBAAuB;QAC3B;QAEA,OAAO,IAAI;IACf;IACO,UAAgB;QACnB,IAAI,CAAC,UAAU,CAAC;QAEhB,IAAI,CAAC,QAAQ,CAAC;YACV,uBAAuB;QAC3B;QAEA,OAAO,IAAI;IACf;AACJ;AAEA,MAAMK;IAGF,SAA4B;QACxB,OAAO,IAAIP;IACf;;aAJS,IAAI,GAAG;;AAKpB;AAEO,MAAMQ,gBAAgBC,UAAU,oBAAoB,CAAC;IACxD,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,19 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { LayoutFieldBuilder } from "./LayoutFieldBuilder.js";
+type AlertType = "info" | "success" | "warning" | "danger";
+export interface IUiAlertFieldBuilder extends LayoutFieldBuilder<"uiAlert"> {
+    alertType(type: AlertType): this;
+}
+declare class UiAlertFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "uiAlert";
+    create(): IUiAlertFieldBuilder;
+}
+export declare const UiAlertFieldType: typeof UiAlertFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        uiAlert(): IUiAlertFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/UiAlertFieldType.js

@@ -0,0 +1,37 @@
+import { FieldType } from "./abstractions.js";
+import { LayoutFieldBuilder } from "./LayoutFieldBuilder.js";
+class AlertFieldBuilder extends LayoutFieldBuilder {
+    constructor(){
+        super("uiAlert"), this._alertType = "warning";
+    }
+    alertType(type) {
+        this._alertType = type;
+        return this;
+    }
+    build() {
+        return {
+            type: "layout",
+            layoutCell: {
+                type: "alert",
+                label: this.config.label,
+                alertType: this._alertType,
+                rules: this.config.rules
+            }
+        };
+    }
+}
+class UiAlertFieldTypeFactory {
+    create() {
+        return new AlertFieldBuilder();
+    }
+    constructor(){
+        this.type = "uiAlert";
+    }
+}
+const UiAlertFieldType = FieldType.createImplementation({
+    implementation: UiAlertFieldTypeFactory,
+    dependencies: []
+});
+export { UiAlertFieldType };
+
+//# sourceMappingURL=UiAlertFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/UiAlertFieldType.js","sources":["../../../../src/features/modelBuilder/fields/UiAlertFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { type LayoutFieldBuildResult } from \"./BaseFieldBuilder.js\";\nimport { LayoutFieldBuilder } from \"./LayoutFieldBuilder.js\";\n\ntype AlertType = \"info\" | \"success\" | \"warning\" | \"danger\";\n\nexport interface IUiAlertFieldBuilder extends LayoutFieldBuilder<\"uiAlert\"> {\n    alertType(type: AlertType): this;\n}\n\nclass AlertFieldBuilder extends LayoutFieldBuilder<\"uiAlert\"> implements IUiAlertFieldBuilder {\n    private _alertType: AlertType = \"warning\";\n\n    public constructor() {\n        super(\"uiAlert\");\n    }\n\n    public alertType(type: AlertType): this {\n        this._alertType = type;\n        return this;\n    }\n\n    public override build(): LayoutFieldBuildResult {\n        return {\n            type: \"layout\",\n            layoutCell: {\n                type: \"alert\",\n                label: this.config.label,\n                alertType: this._alertType,\n                rules: this.config.rules\n            }\n        };\n    }\n}\n\nclass UiAlertFieldTypeFactory implements IFieldTypeFactory {\n    public readonly type = \"uiAlert\";\n\n    public create(): IUiAlertFieldBuilder {\n        return new AlertFieldBuilder();\n    }\n}\n\nexport const UiAlertFieldType = FieldType.createImplementation({\n    implementation: UiAlertFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        uiAlert(): IUiAlertFieldBuilder;\n    }\n}\n"],"names":["AlertFieldBuilder","LayoutFieldBuilder","type","UiAlertFieldTypeFactory","UiAlertFieldType","FieldType"],"mappings":";;AAUA,MAAMA,0BAA0BC;IAG5B,aAAqB;QACjB,KAAK,CAAC,iBAHF,UAAU,GAAc;IAIhC;IAEO,UAAUC,IAAe,EAAQ;QACpC,IAAI,CAAC,UAAU,GAAGA;QAClB,OAAO,IAAI;IACf;IAEgB,QAAgC;QAC5C,OAAO;YACH,MAAM;YACN,YAAY;gBACR,MAAM;gBACN,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;gBACxB,WAAW,IAAI,CAAC,UAAU;gBAC1B,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;YAC5B;QACJ;IACJ;AACJ;AAEA,MAAMC;IAGK,SAA+B;QAClC,OAAO,IAAIH;IACf;;aAJgB,IAAI,GAAG;;AAK3B;AAEO,MAAMI,mBAAmBC,UAAU,oBAAoB,CAAC;IAC3D,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,17 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { LayoutFieldBuilder } from "./LayoutFieldBuilder.js";
+export interface IUiSeparatorFieldBuilder extends LayoutFieldBuilder<"uiSeparator"> {
+}
+declare class UiSeparatorFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "uiSeparator";
+    create(): IUiSeparatorFieldBuilder;
+}
+export declare const UiSeparatorFieldType: typeof UiSeparatorFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        uiSeparator(): IUiSeparatorFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/UiSeparatorFieldType.js

@@ -0,0 +1,33 @@
+import { FieldType } from "./abstractions.js";
+import { LayoutFieldBuilder } from "./LayoutFieldBuilder.js";
+class SeparatorFieldBuilder extends LayoutFieldBuilder {
+    constructor(){
+        super("uiSeparator");
+    }
+    build() {
+        return {
+            type: "layout",
+            layoutCell: {
+                type: "separator",
+                label: this.config.label,
+                description: this.config.description,
+                rules: this.config.rules
+            }
+        };
+    }
+}
+class UiSeparatorFieldTypeFactory {
+    create() {
+        return new SeparatorFieldBuilder();
+    }
+    constructor(){
+        this.type = "uiSeparator";
+    }
+}
+const UiSeparatorFieldType = FieldType.createImplementation({
+    implementation: UiSeparatorFieldTypeFactory,
+    dependencies: []
+});
+export { UiSeparatorFieldType };
+
+//# sourceMappingURL=UiSeparatorFieldType.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/UiSeparatorFieldType.js","sources":["../../../../src/features/modelBuilder/fields/UiSeparatorFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { type LayoutFieldBuildResult } from \"./BaseFieldBuilder.js\";\nimport { LayoutFieldBuilder } from \"./LayoutFieldBuilder.js\";\n\nexport interface IUiSeparatorFieldBuilder extends LayoutFieldBuilder<\"uiSeparator\"> {}\n\nclass SeparatorFieldBuilder\n    extends LayoutFieldBuilder<\"uiSeparator\">\n    implements IUiSeparatorFieldBuilder\n{\n    public constructor() {\n        super(\"uiSeparator\");\n    }\n\n    public override build(): LayoutFieldBuildResult {\n        return {\n            type: \"layout\",\n            layoutCell: {\n                type: \"separator\",\n                label: this.config.label,\n                description: this.config.description,\n                rules: this.config.rules\n            }\n        };\n    }\n}\n\nclass UiSeparatorFieldTypeFactory implements IFieldTypeFactory {\n    public readonly type = \"uiSeparator\";\n\n    public create(): IUiSeparatorFieldBuilder {\n        return new SeparatorFieldBuilder();\n    }\n}\n\nexport const UiSeparatorFieldType = FieldType.createImplementation({\n    implementation: UiSeparatorFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        uiSeparator(): IUiSeparatorFieldBuilder;\n    }\n}\n"],"names":["SeparatorFieldBuilder","LayoutFieldBuilder","UiSeparatorFieldTypeFactory","UiSeparatorFieldType","FieldType"],"mappings":";;AAMA,MAAMA,8BACMC;IAGR,aAAqB;QACjB,KAAK,CAAC;IACV;IAEgB,QAAgC;QAC5C,OAAO;YACH,MAAM;YACN,YAAY;gBACR,MAAM;gBACN,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;gBACxB,aAAa,IAAI,CAAC,MAAM,CAAC,WAAW;gBACpC,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;YAC5B;QACJ;IACJ;AACJ;AAEA,MAAMC;IAGK,SAAmC;QACtC,OAAO,IAAIF;IACf;;aAJgB,IAAI,GAAG;;AAK3B;AAEO,MAAMG,uBAAuBC,UAAU,oBAAoB,CAAC;IAC/D,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,29 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { BaseFieldBuilder } from "./BaseFieldBuilder.js";
+import { LayoutFieldBuilder } from "./LayoutFieldBuilder.js";
+import { type IFieldBuilderRegistry } from "../abstractions.js";
+import type { CmsIcon, FieldRule } from "../../../types/index.js";
+interface ITabConfig {
+    label: string;
+    icon?: CmsIcon;
+    description?: string;
+    fields: (registry: IFieldBuilderRegistry) => Record<string, BaseFieldBuilder<any>>;
+    layout?: string[][];
+    rules?: FieldRule[];
+}
+export interface IUiTabsFieldBuilder extends LayoutFieldBuilder<"uiTabs"> {
+    tab(id: string, config: ITabConfig): this;
+}
+declare class TabsFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "uiTabs";
+    create(registry: IFieldBuilderRegistry): IUiTabsFieldBuilder;
+}
+export declare const UiTabsFieldType: typeof TabsFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        uiTabs(): IUiTabsFieldBuilder;
+    }
+}
+export {};