@prismicio/mock 0.0.4 → 0.0.8

package/dist/value/{index.mjs → index.js}

@@ -1,23 +1,59 @@
-import * as fakerLocaleEN from 'faker/lib/locales/en';
-import Faker from 'faker/lib';
-import * as prismicT from '@prismicio/types';
-import * as changeCase from 'change-case';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fakerLocaleEN = require('faker/lib/locales/en/index.js');
+const Faker = require('faker/lib/index.js');
+const prismicT = require('@prismicio/types');
+const changeCase = require('change-case');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+	if (e && e.__esModule) return e;
+	const n = Object.create(null);
+	if (e) {
+		for (const k in e) {
+			if (k !== 'default') {
+				const d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		}
+	}
+	n["default"] = e;
+	return Object.freeze(n);
+}
+
+const fakerLocaleEN__namespace = /*#__PURE__*/_interopNamespace(fakerLocaleEN);
+const Faker__default = /*#__PURE__*/_interopDefaultLegacy(Faker);
+const prismicT__namespace = /*#__PURE__*/_interopNamespace(prismicT);
+const changeCase__namespace = /*#__PURE__*/_interopNamespace(changeCase);
 
 const FAKER_SEED = 1984;
 
 const createFaker = (seed = FAKER_SEED) => {
-  if (createFaker.cache[seed]) {
-    return createFaker.cache[seed];
+  let normalizedSeed;
+  if (typeof seed === "string") {
+    normalizedSeed = seed.split("").map((char) => char.charCodeAt(0));
+  } else {
+    normalizedSeed = seed;
+  }
+  const cacheKey = JSON.stringify(normalizedSeed);
+  if (createFaker.cache[cacheKey]) {
+    return createFaker.cache[cacheKey];
   }
-  const seededFaker = new Faker();
-  seededFaker.seed(seed);
-  seededFaker.locales["en"] = fakerLocaleEN;
-  createFaker.cache[seed] = seededFaker;
-  return seededFaker;
+  const fakerInstance = new Faker__default["default"]();
+  fakerInstance.locales["en"] = fakerLocaleEN__namespace;
+  fakerInstance.seed(normalizedSeed);
+  createFaker.cache[cacheKey] = fakerInstance;
+  return fakerInstance;
 };
 createFaker.cache = {};
 
-const boolean$1 = (config = {}) => {
+const boolean = (config = {}) => {
   const faker = createFaker(config.seed);
   return faker.datatype.boolean();
 };
@@ -28,36 +64,36 @@ const generateTags = (config) => {
   return Array(faker.datatype.number({
     min: (_a = config.min) != null ? _a : 0,
     max: (_b = config.max) != null ? _b : 2
-  })).fill(void 0).map(() => changeCase.capitalCase(faker.lorem.words(faker.datatype.number({ min: 1, max: 3 }))));
+  })).fill(void 0).map(() => changeCase__namespace.capitalCase(faker.lorem.words(faker.datatype.number({ min: 1, max: 3 }))));
 };
 
 const valueForModel = (config) => {
   const model = config.model;
   switch (model.type) {
-    case prismicT.CustomTypeModelFieldType.Boolean: {
-      return boolean$1({
+    case prismicT__namespace.CustomTypeModelFieldType.Boolean: {
+      return boolean({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Color: {
+    case prismicT__namespace.CustomTypeModelFieldType.Color: {
       return color({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Link: {
+    case prismicT__namespace.CustomTypeModelFieldType.Link: {
       switch (model.config.select) {
-        case prismicT.CustomTypeModelLinkSelectType.Document: {
+        case prismicT__namespace.CustomTypeModelLinkSelectType.Document: {
           return contentRelationship({
             seed: config.seed,
             model,
             ...config.config
           });
         }
-        case prismicT.CustomTypeModelLinkSelectType.Media: {
+        case prismicT__namespace.CustomTypeModelLinkSelectType.Media: {
           return linkToMedia({
             seed: config.seed,
             model,
@@ -73,63 +109,63 @@ const valueForModel = (config) => {
         }
       }
     }
-    case prismicT.CustomTypeModelFieldType.Date: {
+    case prismicT__namespace.CustomTypeModelFieldType.Date: {
       return date({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Embed: {
+    case prismicT__namespace.CustomTypeModelFieldType.Embed: {
       return embed$1({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.GeoPoint: {
+    case prismicT__namespace.CustomTypeModelFieldType.GeoPoint: {
       return geoPoint({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Image: {
+    case prismicT__namespace.CustomTypeModelFieldType.Image: {
       return image$1({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Text: {
+    case prismicT__namespace.CustomTypeModelFieldType.Text: {
       return keyText({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Number: {
+    case prismicT__namespace.CustomTypeModelFieldType.Number: {
       return number({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Select: {
+    case prismicT__namespace.CustomTypeModelFieldType.Select: {
       return select({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Timestamp: {
+    case prismicT__namespace.CustomTypeModelFieldType.Timestamp: {
       return timestamp({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.StructuredText: {
+    case prismicT__namespace.CustomTypeModelFieldType.StructuredText: {
       if ("single" in model.config && model.config.single.split(",").every((element) => /heading[1-6]/.test(element.trim()))) {
         return title({
           seed: config.seed,
@@ -144,28 +180,28 @@ const valueForModel = (config) => {
         });
       }
     }
-    case prismicT.CustomTypeModelFieldType.IntegrationFields: {
+    case prismicT__namespace.CustomTypeModelFieldType.IntegrationFields: {
       return integrationFields({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.UID: {
+    case prismicT__namespace.CustomTypeModelFieldType.UID: {
       return uid({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Group: {
+    case prismicT__namespace.CustomTypeModelFieldType.Group: {
       return group({
         seed: config.seed,
         model,
         ...config.config
       });
     }
-    case prismicT.CustomTypeModelFieldType.Slices: {
+    case prismicT__namespace.CustomTypeModelFieldType.Slices: {
       return sliceZone({
         seed: config.seed,
         model,
@@ -177,51 +213,51 @@ const valueForModel = (config) => {
 
 const getValueConfigType = (model) => {
   switch (model.type) {
-    case prismicT.CustomTypeModelFieldType.Boolean:
+    case prismicT__namespace.CustomTypeModelFieldType.Boolean:
       return "boolean";
-    case prismicT.CustomTypeModelFieldType.Color:
+    case prismicT__namespace.CustomTypeModelFieldType.Color:
       return "color";
-    case prismicT.CustomTypeModelFieldType.Date:
+    case prismicT__namespace.CustomTypeModelFieldType.Date:
       return "date";
-    case prismicT.CustomTypeModelFieldType.Embed:
+    case prismicT__namespace.CustomTypeModelFieldType.Embed:
       return "embed";
-    case prismicT.CustomTypeModelFieldType.GeoPoint:
+    case prismicT__namespace.CustomTypeModelFieldType.GeoPoint:
       return "geoPoint";
-    case prismicT.CustomTypeModelFieldType.Group:
+    case prismicT__namespace.CustomTypeModelFieldType.Group:
       return "group";
-    case prismicT.CustomTypeModelFieldType.Image:
+    case prismicT__namespace.CustomTypeModelFieldType.Image:
       return "image";
-    case prismicT.CustomTypeModelFieldType.Link: {
+    case prismicT__namespace.CustomTypeModelFieldType.Link: {
       switch (model.config.select) {
-        case prismicT.CustomTypeModelLinkSelectType.Document:
+        case prismicT__namespace.CustomTypeModelLinkSelectType.Document:
           return "contentRelationship";
-        case prismicT.CustomTypeModelLinkSelectType.Media:
+        case prismicT__namespace.CustomTypeModelLinkSelectType.Media:
           return "linkToMedia";
         default:
           return "link";
       }
     }
-    case prismicT.CustomTypeModelFieldType.Number:
+    case prismicT__namespace.CustomTypeModelFieldType.Number:
       return "number";
-    case prismicT.CustomTypeModelFieldType.Select:
+    case prismicT__namespace.CustomTypeModelFieldType.Select:
       return "select";
-    case prismicT.CustomTypeModelFieldType.StructuredText: {
+    case prismicT__namespace.CustomTypeModelFieldType.StructuredText: {
       if ("single" in model.config && model.config.single.split(",").every((element) => /heading{1,6}/.test(element.trim()))) {
         return "title";
       } else {
         return "richText";
       }
     }
-    case prismicT.CustomTypeModelFieldType.Text:
+    case prismicT__namespace.CustomTypeModelFieldType.Text:
       return "keyText";
-    case prismicT.CustomTypeModelFieldType.Timestamp:
+    case prismicT__namespace.CustomTypeModelFieldType.Timestamp:
       return "timestamp";
-    case prismicT.CustomTypeModelFieldType.UID:
+    case prismicT__namespace.CustomTypeModelFieldType.UID:
       return "uid";
-    case prismicT.CustomTypeModelFieldType.IntegrationFields:
+    case prismicT__namespace.CustomTypeModelFieldType.IntegrationFields:
       return "integrationFields";
-    case prismicT.CustomTypeModelFieldType.Slices:
-      return "slices";
+    case prismicT__namespace.CustomTypeModelFieldType.Slices:
+      return "sliceZone";
   }
 };
 const valueForModelMap = (config) => {
@@ -240,117 +276,74 @@ const valueForModelMap = (config) => {
   return result;
 };
 
-const boolean = (config = {}) => {
-  const faker = createFaker(config.seed);
-  return {
-    type: prismicT.CustomTypeModelFieldType.Boolean,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun())
-    }
-  };
-};
-
-const color$1 = (config = {}) => {
-  const faker = createFaker(config.seed);
-  return {
-    type: prismicT.CustomTypeModelFieldType.Color,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3))
-    }
-  };
-};
-
-const generateCustomTypeId = (config) => {
-  const faker = createFaker(config.seed);
-  return changeCase.snakeCase(faker.company.bsNoun());
-};
-
 const contentRelationship$1 = (config = {}) => {
   const faker = createFaker(config.seed);
   return {
-    type: prismicT.CustomTypeModelFieldType.Link,
+    type: prismicT__namespace.CustomTypeModelFieldType.Link,
     config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
-      select: prismicT.CustomTypeModelLinkSelectType.Document,
-      customtypes: config.constrainCustomTypes ? Array(faker.datatype.number({ min: 1, max: 3 })).fill(void 0).map(() => generateCustomTypeId({ seed: config.seed })) : void 0,
-      tags: config.constrainTags ? Array(faker.datatype.number({ min: 1, max: 3 })).fill(void 0).map(() => changeCase.capitalCase(faker.lorem.words(faker.datatype.number({ min: 1, max: 3 })))) : void 0
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3)),
+      select: prismicT__namespace.CustomTypeModelLinkSelectType.Document,
+      customtypes: config.customTypeIDs,
+      tags: config.tags
     }
   };
 };
 
-const date$1 = (config = {}) => {
-  const faker = createFaker(config.seed);
-  return {
-    type: prismicT.CustomTypeModelFieldType.Date,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3))
-    }
-  };
-};
-
-const embed$2 = (config = {}) => {
+const customType$1 = (config = {}) => {
+  var _a, _b;
   const faker = createFaker(config.seed);
+  let label = config.label || changeCase__namespace.capitalCase(faker.company.bsNoun());
+  let id = config.id || changeCase__namespace.snakeCase(label);
+  if (config.id && !config.label) {
+    label = changeCase__namespace.capitalCase(config.id);
+  } else if (config.label && !config.label) {
+    id = changeCase__namespace.snakeCase(config.label);
+  }
+  let json = {};
+  if ("fields" in config && config.fields) {
+    json = { Main: config.fields };
+  } else if ("tabs" in config && config.tabs) {
+    json = config.tabs;
+  }
   return {
-    type: prismicT.CustomTypeModelFieldType.Embed,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3))
-    }
+    id,
+    label,
+    status: (_a = config.status) != null ? _a : faker.datatype.boolean(),
+    repeatable: (_b = config.repeatable) != null ? _b : faker.datatype.boolean(),
+    json
   };
 };
 
-const geoPoint$1 = (config = {}) => {
+const group$1 = (config = {}) => {
   const faker = createFaker(config.seed);
   return {
-    type: prismicT.CustomTypeModelFieldType.GeoPoint,
+    type: prismicT__namespace.CustomTypeModelFieldType.Group,
     config: {
-      label: changeCase.capitalCase(faker.company.bsNoun())
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      fields: config.fields || {}
     }
   };
 };
 
 const image$2 = (config = {}) => {
-  var _a;
   const faker = createFaker(config.seed);
-  const thumbnailsCount = (_a = config.thumbnailsCount) != null ? _a : faker.datatype.number(3);
+  const thumbnails = (config.thumbnailNames || []).map((name) => {
+    return {
+      name,
+      width: faker.datatype.number({ min: 500, max: 2e3 }),
+      height: faker.datatype.number({ min: 500, max: 2e3 })
+    };
+  });
   return {
-    type: prismicT.CustomTypeModelFieldType.Image,
+    type: prismicT__namespace.CustomTypeModelFieldType.Image,
     config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
       constraint: {
         width: config.withConstraint ? faker.datatype.number({ min: 500, max: 2e3 }) : null,
         height: config.withConstraint ? faker.datatype.number({ min: 500, max: 2e3 }) : null
       },
-      thumbnails: Array(thumbnailsCount).fill(void 0).map(() => ({
-        name: changeCase.capitalCase(faker.company.bsNoun()),
-        width: faker.datatype.number({ min: 500, max: 2e3 }),
-        height: faker.datatype.number({ min: 500, max: 2e3 })
-      }))
-    }
-  };
-};
-
-const integrationFields$1 = (config = {}) => {
-  const faker = createFaker(config.seed);
-  return {
-    type: prismicT.CustomTypeModelFieldType.IntegrationFields,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      catalog: changeCase.snakeCase(faker.lorem.words(4))
-    }
-  };
-};
-
-const keyText$1 = (config = {}) => {
-  const faker = createFaker(config.seed);
-  return {
-    type: prismicT.CustomTypeModelFieldType.Text,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3))
+      thumbnails
     }
   };
 };
@@ -358,65 +351,42 @@ const keyText$1 = (config = {}) => {
 const link$1 = (config = {}) => {
   const faker = createFaker(config.seed);
   return {
-    type: prismicT.CustomTypeModelFieldType.Link,
+    type: prismicT__namespace.CustomTypeModelFieldType.Link,
     config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3)),
       select: null,
       allowTargetBlank: ("allowTargetBlank" in config ? config.allowTargetBlank : faker.datatype.boolean()) || void 0
     }
   };
 };
 
-const linkToMedia$1 = (config = {}) => {
-  const faker = createFaker(config.seed);
-  return {
-    type: prismicT.CustomTypeModelFieldType.Link,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
-      select: prismicT.CustomTypeModelLinkSelectType.Media
-    }
-  };
-};
-
-const number$1 = (config = {}) => {
-  const faker = createFaker(config.seed);
-  return {
-    type: prismicT.CustomTypeModelFieldType.Number,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3))
-    }
-  };
-};
-
 const richText$1 = (config = {}) => {
   var _a;
   const faker = createFaker(config.seed);
   const blockTypes = faker.random.arrayElements([
-    prismicT.RichTextNodeType.heading1,
-    prismicT.RichTextNodeType.heading2,
-    prismicT.RichTextNodeType.heading3,
-    prismicT.RichTextNodeType.heading4,
-    prismicT.RichTextNodeType.heading5,
-    prismicT.RichTextNodeType.heading6,
-    prismicT.RichTextNodeType.paragraph,
-    prismicT.RichTextNodeType.preformatted,
-    prismicT.RichTextNodeType.strong,
-    prismicT.RichTextNodeType.em,
-    prismicT.RichTextNodeType.listItem,
-    prismicT.RichTextNodeType.oListItem,
-    prismicT.RichTextNodeType.image,
-    prismicT.RichTextNodeType.embed,
-    prismicT.RichTextNodeType.hyperlink
+    prismicT__namespace.RichTextNodeType.heading1,
+    prismicT__namespace.RichTextNodeType.heading2,
+    prismicT__namespace.RichTextNodeType.heading3,
+    prismicT__namespace.RichTextNodeType.heading4,
+    prismicT__namespace.RichTextNodeType.heading5,
+    prismicT__namespace.RichTextNodeType.heading6,
+    prismicT__namespace.RichTextNodeType.paragraph,
+    prismicT__namespace.RichTextNodeType.preformatted,
+    prismicT__namespace.RichTextNodeType.strong,
+    prismicT__namespace.RichTextNodeType.em,
+    prismicT__namespace.RichTextNodeType.listItem,
+    prismicT__namespace.RichTextNodeType.oListItem,
+    prismicT__namespace.RichTextNodeType.image,
+    prismicT__namespace.RichTextNodeType.embed,
+    prismicT__namespace.RichTextNodeType.hyperlink
   ]).join(",");
   const blockTypeConfig = ((_a = config.withMultipleBlocks) != null ? _a : faker.datatype.boolean()) ? { multi: blockTypes } : { single: blockTypes };
   return {
-    type: prismicT.CustomTypeModelFieldType.StructuredText,
+    type: prismicT__namespace.CustomTypeModelFieldType.StructuredText,
     config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3)),
       allowTargetBlank: faker.datatype.boolean() ? true : void 0,
       ...blockTypeConfig
     }
@@ -424,255 +394,127 @@ const richText$1 = (config = {}) => {
 };
 
 const select$1 = (config = {}) => {
-  var _a;
   const faker = createFaker(config.seed);
-  const optionsCount = (_a = config.optionsCount) != null ? _a : faker.datatype.number({ min: 1, max: 5 });
-  const options = Array(optionsCount).fill(void 0).map(() => changeCase.capitalCase(faker.company.bsBuzz()));
   return {
-    type: prismicT.CustomTypeModelFieldType.Select,
+    type: prismicT__namespace.CustomTypeModelFieldType.Select,
     config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
-      options,
-      default_value: config.withDefaultValue ? faker.random.arrayElement(options) : void 0
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3)),
+      options: config.options || [],
+      default_value: config.defaultValue || void 0
     }
   };
 };
 
-const timestamp$1 = (config = {}) => {
-  const faker = createFaker(config.seed);
-  return {
-    type: prismicT.CustomTypeModelFieldType.Timestamp,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3))
-    }
-  };
-};
-
-const title$1 = (config = {}) => {
+const sharedSlice$1 = (config = {}) => {
   const faker = createFaker(config.seed);
-  const single = faker.random.arrayElements([
-    "heading1",
-    "heading2",
-    "heading3",
-    "heading4",
-    "heading5",
-    "heading6"
-  ]).join(",");
+  let name = config.name || changeCase__namespace.capitalCase(faker.company.bsNoun());
+  let id = config.id || changeCase__namespace.snakeCase(name);
+  if (config.id && !config.name) {
+    name = changeCase__namespace.pascalCase(config.id);
+  } else if (config.name && !config.name) {
+    id = changeCase__namespace.snakeCase(config.name);
+  }
   return {
-    type: prismicT.CustomTypeModelFieldType.StructuredText,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3)),
-      single,
-      allowTargetBlank: faker.datatype.boolean() ? true : void 0
-    }
+    type: prismicT__namespace.CustomTypeModelSliceType.SharedSlice,
+    id,
+    name,
+    description: faker.lorem.sentence(),
+    variations: config.variations || []
   };
 };
 
-const generateFieldId = (config) => {
-  const faker = createFaker(config.seed);
-  return changeCase.snakeCase(faker.lorem.words(faker.datatype.number({ min: 1, max: 3 })));
-};
-
-const mockModelFns = {
-  boolean,
-  color: color$1,
-  contentRelationship: contentRelationship$1,
-  date: date$1,
-  embed: embed$2,
-  geoPoint: geoPoint$1,
-  image: image$2,
-  integrationFields: integrationFields$1,
-  keyText: keyText$1,
-  link: link$1,
-  linkToMedia: linkToMedia$1,
-  number: number$1,
-  richText: richText$1,
-  select: select$1,
-  timestamp: timestamp$1,
-  title: title$1
-};
-const buildMockGroupFieldMap = (config = {}) => {
-  var _a;
+const sharedSliceVariation$1 = (config = {}) => {
   const faker = createFaker(config.seed);
-  const configs = config.configs || {};
-  const fields = {};
-  for (const mockModelType in mockModelFns) {
-    const mockModelFn = mockModelFns[mockModelType];
-    const mockModelMapConfig = configs[mockModelType] || {};
-    const count = (_a = mockModelMapConfig.count) != null ? _a : faker.random.arrayElement([0, 0, 0, 1]);
-    for (let i = 0; i < count; i++) {
-      const fieldId = generateFieldId({ seed: config.seed });
-      fields[fieldId] = mockModelFn({
-        seed: config.seed,
-        ...mockModelMapConfig.config
-      });
-    }
+  let name = config.name || changeCase__namespace.capitalCase(faker.company.bsNoun());
+  let id = config.id || changeCase__namespace.snakeCase(name);
+  if (config.id && !config.name) {
+    name = changeCase__namespace.pascalCase(config.id);
+  } else if (config.name && !config.name) {
+    id = changeCase__namespace.snakeCase(config.name);
   }
-  return fields;
-};
-
-const uid$1 = (config = {}) => {
-  const faker = createFaker(config.seed);
   return {
-    type: prismicT.CustomTypeModelFieldType.UID,
-    config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      placeholder: changeCase.sentenceCase(faker.lorem.words(3))
-    }
-  };
-};
-
-const sharedSliceChoice = () => {
-  return {
-    type: prismicT.CustomTypeModelSliceType.SharedSlice
+    id,
+    name,
+    description: faker.lorem.sentence(),
+    docURL: faker.internet.url(),
+    version: faker.git.shortSha(),
+    primary: config.primaryFields || {},
+    items: config.itemsFields || {}
   };
 };
 
 const slice$1 = (config = {}) => {
-  var _a, _b, _c, _d, _e, _f;
   const faker = createFaker(config.seed);
   return {
-    type: prismicT.CustomTypeModelSliceType.Slice,
-    icon: changeCase.snakeCase(faker.company.bsNoun()),
-    display: faker.datatype.boolean() ? prismicT.CustomTypeModelSliceDisplay.Grid : prismicT.CustomTypeModelSliceDisplay.List,
-    fieldset: changeCase.capitalCase(faker.lorem.words()),
+    type: prismicT__namespace.CustomTypeModelSliceType.Slice,
+    icon: changeCase__namespace.snakeCase(faker.company.bsNoun()),
+    display: faker.datatype.boolean() ? prismicT__namespace.CustomTypeModelSliceDisplay.Grid : prismicT__namespace.CustomTypeModelSliceDisplay.List,
+    fieldset: changeCase__namespace.capitalCase(faker.lorem.words()),
     description: faker.lorem.sentence(),
-    repeat: buildMockGroupFieldMap({
-      seed: (_b = (_a = config.repeatFieldConfig) == null ? void 0 : _a.seed) != null ? _b : config.seed,
-      configs: (_c = config.repeatFieldConfig) == null ? void 0 : _c.configs
-    }),
-    "non-repeat": buildMockGroupFieldMap({
-      seed: (_e = (_d = config.nonRepeatFieldConfig) == null ? void 0 : _d.seed) != null ? _e : config.seed,
-      configs: (_f = config.nonRepeatFieldConfig) == null ? void 0 : _f.configs
-    })
+    repeat: config.repeatFields || {},
+    "non-repeat": config.nonRepeatFields || {}
   };
 };
 
 const sliceZone$1 = (config = {}) => {
-  var _a;
-  const faker = createFaker(config.seed);
-  const choicesCount = (_a = config.choicesCount) != null ? _a : faker.datatype.number({ min: 2, max: 6 });
-  const choices = {};
-  for (let i = 0; i < choicesCount; i++) {
-    const choiceId = generateFieldId({ seed: config.seed });
-    choices[choiceId] = config.withSharedSlices ? sharedSliceChoice() : slice$1({ seed: config.seed });
-  }
   const labels = {};
-  if (!config.withSharedSlices) {
-    for (const choiceId in choices) {
-      const labelsCount = faker.datatype.number({ min: 0, max: 3 });
-      labels[choiceId] = Array(labelsCount).fill(void 0).map(() => ({
-        name: changeCase.capitalCase(faker.company.bsNoun()),
-        display: faker.datatype.boolean() ? prismicT.CustomTypeModelSliceDisplay.Grid : prismicT.CustomTypeModelSliceDisplay.List
-      }));
+  for (const choiceId in config.choices) {
+    const choice = config.choices[choiceId];
+    if (choice.type === prismicT__namespace.CustomTypeModelSliceType.Slice) {
+      labels[choiceId] = [];
     }
   }
   return {
-    type: prismicT.CustomTypeModelFieldType.Slices,
+    type: prismicT__namespace.CustomTypeModelFieldType.Slices,
     fieldset: "Slice zone",
     config: {
       labels,
-      choices
-    }
-  };
-};
-
-const customType$1 = (config = {}) => {
-  var _a;
-  const faker = createFaker(config.seed);
-  const tabsCount = (_a = config.tabsCount) != null ? _a : faker.datatype.number({ min: 1, max: 3 });
-  const json = {};
-  for (let i = 0; i < tabsCount; i++) {
-    const tabName = changeCase.capitalCase(faker.company.bsNoun());
-    const tabFields = buildMockGroupFieldMap({
-      seed: config.seed,
-      configs: config.configs
-    });
-    if (i === 0 && config.withUID) {
-      const fieldId = generateFieldId({ seed: config.seed });
-      tabFields[fieldId] = uid$1();
+      choices: config.choices || {}
     }
-    if (config.withSliceZones) {
-      const sliceZoneId = generateFieldId({ seed: config.seed });
-      tabFields[sliceZoneId] = sliceZone$1({
-        withSharedSlices: config.withSharedSlices
-      });
-    }
-    json[tabName] = tabFields;
-  }
-  const id = generateCustomTypeId({ seed: config.seed });
-  return {
-    id,
-    label: changeCase.capitalCase(id),
-    status: faker.datatype.boolean(),
-    repeatable: faker.datatype.boolean(),
-    json
   };
 };
 
-const group$1 = (config = {}) => {
+const title$1 = (config = {}) => {
   const faker = createFaker(config.seed);
-  const fields = buildMockGroupFieldMap({
-    seed: config.seed,
-    configs: config.configs
-  });
+  const single = faker.random.arrayElements([
+    "heading1",
+    "heading2",
+    "heading3",
+    "heading4",
+    "heading5",
+    "heading6"
+  ]).join(",");
   return {
-    type: prismicT.CustomTypeModelFieldType.Group,
+    type: prismicT__namespace.CustomTypeModelFieldType.StructuredText,
     config: {
-      label: changeCase.capitalCase(faker.company.bsNoun()),
-      fields
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3)),
+      single,
+      allowTargetBlank: faker.datatype.boolean() ? true : void 0
     }
   };
 };
 
-const sharedSliceVariation$1 = (config = {}) => {
-  var _a, _b, _c, _d, _e, _f;
-  const faker = createFaker(config.seed);
-  const name = changeCase.capitalCase(faker.company.bsNoun());
-  return {
-    id: changeCase.snakeCase(name),
-    name,
-    description: faker.lorem.sentence(),
-    docURL: faker.internet.url(),
-    version: faker.git.shortSha(),
-    primary: buildMockGroupFieldMap({
-      seed: (_b = (_a = config.primaryFieldConfig) == null ? void 0 : _a.seed) != null ? _b : config.seed,
-      configs: (_c = config.primaryFieldConfig) == null ? void 0 : _c.configs
-    }),
-    items: buildMockGroupFieldMap({
-      seed: (_e = (_d = config.itemsFieldConfig) == null ? void 0 : _d.seed) != null ? _e : config.seed,
-      configs: (_f = config.itemsFieldConfig) == null ? void 0 : _f.configs
-    })
-  };
-};
-
-const sharedSlice$1 = (config = {}) => {
-  var _a;
+const generateFieldId = (config) => {
   const faker = createFaker(config.seed);
-  const variationsCount = (_a = config.variationsCount) != null ? _a : faker.datatype.number({ min: 1, max: 3 });
-  const name = changeCase.capitalCase(faker.company.bsNoun());
-  const variations = Array(variationsCount).fill(void 0).map(() => sharedSliceVariation$1({
-    seed: config.seed,
-    itemsFieldConfig: config.itemsFieldConfig,
-    primaryFieldConfig: config.primaryFieldConfig
-  }));
-  return {
-    type: prismicT.CustomTypeModelSliceType.SharedSlice,
-    id: changeCase.snakeCase(name),
-    name,
-    description: faker.lorem.sentence(),
-    variations
-  };
+  return changeCase__namespace.snakeCase(faker.lorem.words(faker.datatype.number({ min: 1, max: 3 })));
 };
 
 const timestamp = (config = {}) => {
   const faker = createFaker(config.seed);
   const after = config.after || faker.date.past(20, new Date("2021-03-07")).toISOString().split("T")[0];
   const before = config.before || faker.date.future(20, new Date("2021-03-07")).toISOString().split("T")[0];
-  return faker.date.between(after, before).toISOString();
+  return config.state === "empty" ? null : faker.date.between(after, before).toISOString();
+};
+
+const buildAlternativeLanguage = (config) => {
+  return {
+    id: config.document.id,
+    type: config.document.type,
+    lang: config.document.lang,
+    uid: config.document.uid || void 0
+  };
 };
 
 const customType = (config = {}) => {
@@ -680,24 +522,34 @@ const customType = (config = {}) => {
   const faker = createFaker(config.seed);
   const model = config.model || customType$1({ seed: config.seed });
   const fieldModelsMap = Object.assign({}, ...Object.values(model.json));
-  const hasUID = Object.values(fieldModelsMap).some((fieldModel) => fieldModel.type === prismicT.CustomTypeModelFieldType.UID);
+  const dataFieldModelsMap = {};
+  for (const key in fieldModelsMap) {
+    const fieldModel = fieldModelsMap[key];
+    if (fieldModel.type !== prismicT__namespace.CustomTypeModelFieldType.UID) {
+      dataFieldModelsMap[key] = fieldModel;
+    }
+  }
+  const hasUID = Object.values(fieldModelsMap).some((fieldModel) => fieldModel.type === prismicT__namespace.CustomTypeModelFieldType.UID);
   const withURL = (_a = config.withURL) != null ? _a : true;
+  const alternateLanguages = (config.alternateLanguages || []).map((alternateLanguageDocument) => buildAlternativeLanguage({
+    document: alternateLanguageDocument
+  }));
   return {
     type: model.id,
     id: faker.git.shortSha(),
-    uid: hasUID ? changeCase.snakeCase(faker.lorem.words(2)) : null,
+    uid: hasUID ? changeCase__namespace.snakeCase(faker.lorem.words(2)) : null,
     url: withURL ? faker.internet.url() : null,
     href: faker.internet.url(),
     lang: faker.lorem.word(),
     tags: generateTags({ seed: config.seed }),
     slugs: [],
     linked_documents: [],
-    alternate_languages: [],
+    alternate_languages: alternateLanguages,
     first_publication_date: timestamp({ seed: config.seed }),
     last_publication_date: timestamp({ seed: config.seed }),
     data: valueForModelMap({
       seed: config.seed,
-      map: fieldModelsMap,
+      map: dataFieldModelsMap,
       configs: config.configs
     })
   };
@@ -705,12 +557,12 @@ const customType = (config = {}) => {
 
 const color = (config = {}) => {
   const faker = createFaker(config.seed);
-  return faker.internet.color().toUpperCase();
+  return config.state === "empty" ? null : faker.internet.color().toUpperCase();
 };
 
 const buildContentRelationshipField = (config) => {
   return {
-    link_type: prismicT.LinkType.Document,
+    link_type: prismicT__namespace.LinkType.Document,
     id: config.document.id,
     uid: config.document.uid || void 0,
     type: config.document.type,
@@ -722,11 +574,18 @@ const buildContentRelationshipField = (config) => {
   };
 };
 
+const generateCustomTypeId = (config) => {
+  const faker = createFaker(config.seed);
+  return changeCase__namespace.snakeCase(faker.company.bsNoun());
+};
+
 const contentRelationship = (config = {}) => {
-  var _a;
   const faker = createFaker(config.seed);
-  const isFilled = (_a = config.isFilled) != null ? _a : true;
-  if (isFilled) {
+  if (config.state === "empty") {
+    return {
+      link_type: prismicT__namespace.LinkType.Document
+    };
+  } else {
     const model = config.model || contentRelationship$1({ seed: config.seed });
     const linkableDocuments = config.linkableDocuments ? config.linkableDocuments.filter((document2) => {
       let shouldKeep = true;
@@ -748,29 +607,28 @@ const contentRelationship = (config = {}) => {
     if (!document) {
       throw new Error("A linkable document could not be found.");
     }
-    return buildContentRelationshipField({ document });
-  } else {
-    return {
-      link_type: prismicT.LinkType.Document
-    };
+    return buildContentRelationshipField({
+      document
+    });
   }
 };
 
 const date = (config = {}) => {
-  return timestamp({
+  return config.state === "empty" ? null : timestamp({
     seed: config.seed,
     after: config.after,
-    before: config.before
+    before: config.before,
+    state: "filled"
   }).split("T")[0];
 };
 
 const buildEmbedField = (config) => {
   const faker = createFaker(config.seed);
   return {
-    type: faker.datatype.boolean() ? prismicT.EmbedType.Link : prismicT.EmbedType.Rich,
+    type: faker.datatype.boolean() ? prismicT__namespace.EmbedType.Link : prismicT__namespace.EmbedType.Rich,
     url: config.embedData.url,
     html: config.embedData.html,
-    title: changeCase.capitalCase(faker.lorem.words(3)),
+    title: changeCase__namespace.capitalCase(faker.lorem.words(3)),
     version: faker.datatype.number({ min: 1, max: 3, precision: 10 }).toString(),
     cache_age: faker.datatype.number(),
     embed_url: config.embedData.embed_url,
@@ -850,67 +708,65 @@ const getMockEmbedData = (config) => {
 
 const embed$1 = (config = {}) => {
   const embedData = getMockEmbedData({ seed: config.seed });
-  return buildEmbedField({ seed: config.seed, embedData });
+  return config.state === "empty" ? {} : buildEmbedField({ seed: config.seed, embedData });
 };
 
 const geoPoint = (config = {}) => {
   const faker = createFaker(config.seed);
   const coordinates = faker.address.nearbyGPSCoordinate();
-  return {
+  return config.state === "empty" ? {} : {
     longitude: Number.parseFloat(coordinates[0]),
     latitude: Number.parseFloat(coordinates[1])
   };
 };
 
-const patterns$9 = {
-  short: {
-    minItems: 1,
-    maxItems: 3
-  },
-  medium: {
-    minItems: 3,
-    maxItems: 6
-  },
-  long: {
-    minItems: 6,
-    maxItems: 12
-  }
-};
 const group = (config = {}) => {
-  const faker = createFaker(config.seed);
-  const model = config.model || group$1({ seed: config.seed });
-  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$9));
-  const pattern = patterns$9[patternKey];
-  const itemsCount = faker.datatype.number({
-    min: pattern.minItems,
-    max: pattern.maxItems
-  });
-  return Array(itemsCount).fill(void 0).map(() => {
-    return valueForModelMap({
-      seed: config.seed,
-      map: model.config.fields,
-      configs: config.configs
+  var _a;
+  if (config.state === "empty") {
+    return [];
+  } else {
+    const faker = createFaker(config.seed);
+    const model = config.model || group$1({ seed: config.seed });
+    const itemsCount = (_a = config.itemsCount) != null ? _a : faker.datatype.number({
+      min: 1,
+      max: 6
     });
-  });
+    return Array(itemsCount).fill(void 0).map(() => {
+      return valueForModelMap({
+        seed: config.seed,
+        map: model.config.fields,
+        configs: config.configs
+      });
+    });
+  }
 };
 
-const buildImageField = (config) => {
+const buildImageFieldImage = (config) => {
   var _a, _b, _c, _d;
-  const faker = createFaker(config.seed);
-  const url = new URL(config.imageData.url);
-  const dimensions = {
-    width: (_b = (_a = config.constraint) == null ? void 0 : _a.width) != null ? _b : config.imageData.width,
-    height: (_d = (_c = config.constraint) == null ? void 0 : _c.height) != null ? _d : config.imageData.height
-  };
-  url.searchParams.set("w", dimensions.width.toString());
-  url.searchParams.set("h", dimensions.height.toString());
-  url.searchParams.set("fit", "crop");
-  return {
-    url: url.toString(),
-    dimensions,
-    alt: faker.lorem.sentence(),
-    copyright: faker.lorem.sentence()
-  };
+  if (config.state === "empty") {
+    return {
+      url: null,
+      dimensions: null,
+      alt: null,
+      copyright: null
+    };
+  } else {
+    const faker = createFaker(config.seed);
+    const url = new URL(config.imageData.url);
+    const dimensions = {
+      width: (_b = (_a = config.constraint) == null ? void 0 : _a.width) != null ? _b : config.imageData.width,
+      height: (_d = (_c = config.constraint) == null ? void 0 : _c.height) != null ? _d : config.imageData.height
+    };
+    url.searchParams.set("w", dimensions.width.toString());
+    url.searchParams.set("h", dimensions.height.toString());
+    url.searchParams.set("fit", "crop");
+    return {
+      url: url.toString(),
+      dimensions,
+      alt: faker.lorem.sentence(),
+      copyright: faker.lorem.sentence()
+    };
+  }
 };
 
 const dataSet = [
@@ -1003,19 +859,21 @@ const getMockImageData = (config) => {
 const image$1 = (config = {}) => {
   const model = config.model || image$2({ seed: config.seed });
   const imageData = getMockImageData({ seed: config.seed });
-  const value = buildImageField({
+  const value = buildImageFieldImage({
     seed: config.seed,
     imageData,
-    constraint: model.config.constraint
+    constraint: model.config.constraint,
+    state: config.state
   });
   for (const thumbnail of model.config.thumbnails) {
-    value[thumbnail.name] = buildImageField({
+    value[thumbnail.name] = buildImageFieldImage({
       seed: config.seed,
       imageData,
       constraint: {
         width: thumbnail.width,
         height: thumbnail.height
-      }
+      },
+      state: config.state
     });
   }
   return value;
@@ -1024,9 +882,9 @@ const image$1 = (config = {}) => {
 const integrationFields = (config = {}) => {
   const faker = createFaker(config.seed);
   const imageData = getMockImageData({ seed: config.seed });
-  return {
+  return config.state === "empty" ? null : {
     id: faker.git.shortSha(),
-    title: changeCase.capitalCase(faker.lorem.words(3)),
+    title: changeCase__namespace.capitalCase(faker.lorem.words(3)),
     description: faker.lorem.sentence(),
     image_url: imageData.url,
     last_update: faker.date.past(20, new Date("2021-03-07")).getTime(),
@@ -1036,16 +894,18 @@ const integrationFields = (config = {}) => {
 
 const keyText = (config = {}) => {
   const faker = createFaker(config.seed);
-  return changeCase.sentenceCase(faker.lorem.words(3));
+  return config.state === "empty" ? null : changeCase__namespace.sentenceCase(faker.lorem.words(3));
 };
 
 const linkToMedia = (config = {}) => {
-  var _a;
   const faker = createFaker(config.seed);
-  const isFilled = (_a = config.isFilled) != null ? _a : true;
-  if (isFilled) {
+  if (config.state === "empty") {
     return {
-      link_type: prismicT.LinkType.Media,
+      link_type: prismicT__namespace.LinkType.Media
+    };
+  } else {
+    return {
+      link_type: prismicT__namespace.LinkType.Media,
       name: faker.system.commonFileName(),
       kind: faker.system.commonFileType(),
       url: faker.internet.url(),
@@ -1053,58 +913,55 @@ const linkToMedia = (config = {}) => {
       height: faker.datatype.number().toString(),
       width: faker.datatype.number().toString()
     };
-  } else {
-    return {
-      link_type: prismicT.LinkType.Media
-    };
   }
 };
 
 const link = (config = {}) => {
-  var _a, _b;
+  var _a;
   const faker = createFaker(config.seed);
-  const isFilled = (_a = config.isFilled) != null ? _a : true;
   const type = config.type || faker.random.arrayElement([
-    prismicT.LinkType.Web,
-    prismicT.LinkType.Document,
-    prismicT.LinkType.Media
+    prismicT__namespace.LinkType.Web,
+    prismicT__namespace.LinkType.Document,
+    prismicT__namespace.LinkType.Media
   ]);
-  if (isFilled) {
+  if (config.state === "empty") {
+    return {
+      link_type: type
+    };
+  } else {
     switch (type) {
-      case prismicT.LinkType.Document: {
+      case prismicT__namespace.LinkType.Document: {
         return contentRelationship({
           seed: config.seed,
-          isFilled,
+          state: config.state,
           linkableDocuments: config.linkableDocuments
         });
       }
-      case prismicT.LinkType.Media: {
+      case prismicT__namespace.LinkType.Media: {
         return linkToMedia({
           seed: config.seed,
-          isFilled
+          state: config.state
         });
       }
-      case prismicT.LinkType.Web: {
+      case prismicT__namespace.LinkType.Web:
+      default: {
         const model = config.model || link$1({ seed: config.seed });
         return {
-          link_type: prismicT.LinkType.Web,
+          link_type: prismicT__namespace.LinkType.Web,
           url: faker.internet.url(),
-          target: ((_b = config.withTargetBlank) != null ? _b : model.config.allowTargetBlank && faker.datatype.boolean()) ? "_blank" : void 0
+          target: ((_a = config.withTargetBlank) != null ? _a : model.config.allowTargetBlank && faker.datatype.boolean()) ? "_blank" : void 0
         };
       }
     }
   }
-  return {
-    link_type: type
-  };
 };
 
 const number = (config = {}) => {
   const faker = createFaker(config.seed);
-  return faker.datatype.number();
+  return config.state === "empty" ? null : faker.datatype.number();
 };
 
-const patterns$8 = {
+const patterns$5 = {
   short: {
     minWords: 1,
     maxWords: 3
@@ -1122,20 +979,20 @@ const heading = (config = {}) => {
   const faker = createFaker(config.seed);
   const model = config.model || title$1({ seed: config.seed });
   const types = ("single" in model.config ? model.config.single : model.config.multi).split(",").filter((type2) => [
-    prismicT.RichTextNodeType.heading1,
-    prismicT.RichTextNodeType.heading2,
-    prismicT.RichTextNodeType.heading3,
-    prismicT.RichTextNodeType.heading4,
-    prismicT.RichTextNodeType.heading5,
-    prismicT.RichTextNodeType.heading6
+    prismicT__namespace.RichTextNodeType.heading1,
+    prismicT__namespace.RichTextNodeType.heading2,
+    prismicT__namespace.RichTextNodeType.heading3,
+    prismicT__namespace.RichTextNodeType.heading4,
+    prismicT__namespace.RichTextNodeType.heading5,
+    prismicT__namespace.RichTextNodeType.heading6
   ].includes(type2));
   const type = faker.random.arrayElement(types);
   if (type) {
-    const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$8));
-    const pattern = patterns$8[patternKey];
+    const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$5));
+    const pattern = patterns$5[patternKey];
     return {
       type,
-      text: changeCase.capitalCase(faker.lorem.words(faker.datatype.number({
+      text: changeCase__namespace.capitalCase(faker.lorem.words(faker.datatype.number({
         min: pattern.minWords,
         max: pattern.maxWords
       }))),
@@ -1146,7 +1003,7 @@ const heading = (config = {}) => {
   }
 };
 
-const patterns$7 = {
+const patterns$4 = {
   short: {
     sentenceCount: 2
   },
@@ -1159,16 +1016,16 @@ const patterns$7 = {
 };
 const paragraph = (config = {}) => {
   const faker = createFaker(config.seed);
-  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$7));
-  const pattern = patterns$7[patternKey];
+  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$4));
+  const pattern = patterns$4[patternKey];
   return {
-    type: prismicT.RichTextNodeType.paragraph,
+    type: prismicT__namespace.RichTextNodeType.paragraph,
     text: faker.lorem.paragraph(pattern.sentenceCount),
     spans: []
   };
 };
 
-const patterns$6 = {
+const patterns$3 = {
   short: {
     sentenceCount: 2
   },
@@ -1181,16 +1038,16 @@ const patterns$6 = {
 };
 const preformatted = (config = {}) => {
   const faker = createFaker(config.seed);
-  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$6));
-  const pattern = patterns$6[patternKey];
+  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$3));
+  const pattern = patterns$3[patternKey];
   return {
-    type: prismicT.RichTextNodeType.preformatted,
+    type: prismicT__namespace.RichTextNodeType.preformatted,
     text: faker.lorem.paragraph(pattern.sentenceCount),
     spans: []
   };
 };
 
-const patterns$5 = {
+const patterns$2 = {
   short: {
     minItems: 1,
     maxItems: 3
@@ -1206,22 +1063,22 @@ const patterns$5 = {
 };
 const list = (config = {}) => {
   const faker = createFaker(config.seed);
-  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$5));
-  const pattern = patterns$5[patternKey];
+  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$2));
+  const pattern = patterns$2[patternKey];
   const itemsCount = faker.datatype.number({
     min: pattern.minItems,
     max: pattern.maxItems
   });
   return Array(itemsCount).fill(void 0).map(() => {
     return {
-      type: prismicT.RichTextNodeType.listItem,
+      type: prismicT__namespace.RichTextNodeType.listItem,
       text: faker.lorem.sentence(),
       spans: []
     };
   });
 };
 
-const patterns$4 = {
+const patterns$1 = {
   short: {
     minItems: 1,
     maxItems: 3
@@ -1237,15 +1094,15 @@ const patterns$4 = {
 };
 const oList = (config = {}) => {
   const faker = createFaker(config.seed);
-  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$4));
-  const pattern = patterns$4[patternKey];
+  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$1));
+  const pattern = patterns$1[patternKey];
   const itemsCount = faker.datatype.number({
     min: pattern.minItems,
     max: pattern.maxItems
   });
   return Array(itemsCount).fill(void 0).map(() => {
     return {
-      type: prismicT.RichTextNodeType.oListItem,
+      type: prismicT__namespace.RichTextNodeType.oListItem,
       text: faker.lorem.sentence(),
       spans: []
     };
@@ -1254,9 +1111,13 @@ const oList = (config = {}) => {
 
 const image = (config = {}) => {
   const imageData = getMockImageData({ seed: config.seed });
-  const imageField = buildImageField({ seed: config.seed, imageData });
+  const imageField = buildImageFieldImage({
+    seed: config.seed,
+    imageData,
+    state: false
+  });
   return {
-    type: prismicT.RichTextNodeType.image,
+    type: prismicT__namespace.RichTextNodeType.image,
     alt: imageField.alt,
     url: imageField.url,
     copyright: imageField.copyright,
@@ -1268,12 +1129,12 @@ const embed = (config = {}) => {
   const embedData = getMockEmbedData({ seed: config.seed });
   const embedField = buildEmbedField({ seed: config.seed, embedData });
   return {
-    type: prismicT.RichTextNodeType.embed,
+    type: prismicT__namespace.RichTextNodeType.embed,
     oembed: embedField
   };
 };
 
-const patterns$3 = {
+const patterns = {
   short: {
     blockCountMin: 1,
     blockCountMax: 2
@@ -1288,18 +1149,18 @@ const patterns$3 = {
   }
 };
 const generators = {
-  [prismicT.RichTextNodeType.heading1]: heading,
-  [prismicT.RichTextNodeType.heading2]: heading,
-  [prismicT.RichTextNodeType.heading3]: heading,
-  [prismicT.RichTextNodeType.heading4]: heading,
-  [prismicT.RichTextNodeType.heading5]: heading,
-  [prismicT.RichTextNodeType.heading6]: heading,
-  [prismicT.RichTextNodeType.paragraph]: paragraph,
-  [prismicT.RichTextNodeType.preformatted]: preformatted,
-  [prismicT.RichTextNodeType.listItem]: list,
-  [prismicT.RichTextNodeType.oListItem]: oList,
-  [prismicT.RichTextNodeType.image]: image,
-  [prismicT.RichTextNodeType.embed]: embed
+  [prismicT__namespace.RichTextNodeType.heading1]: heading,
+  [prismicT__namespace.RichTextNodeType.heading2]: heading,
+  [prismicT__namespace.RichTextNodeType.heading3]: heading,
+  [prismicT__namespace.RichTextNodeType.heading4]: heading,
+  [prismicT__namespace.RichTextNodeType.heading5]: heading,
+  [prismicT__namespace.RichTextNodeType.heading6]: heading,
+  [prismicT__namespace.RichTextNodeType.paragraph]: paragraph,
+  [prismicT__namespace.RichTextNodeType.preformatted]: preformatted,
+  [prismicT__namespace.RichTextNodeType.listItem]: list,
+  [prismicT__namespace.RichTextNodeType.oListItem]: oList,
+  [prismicT__namespace.RichTextNodeType.image]: image,
+  [prismicT__namespace.RichTextNodeType.embed]: embed
 };
 const richText = (config = {}) => {
   const faker = createFaker(config.seed);
@@ -1310,8 +1171,8 @@ const richText = (config = {}) => {
   const supportsMultipleBlocks = "multi" in model.config;
   const types = ("multi" in model.config ? model.config.multi : model.config.single).split(",").filter((type) => Object.keys(generators).includes(type));
   if (types.length > 0) {
-    const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$3));
-    const pattern = patterns$3[patternKey];
+    const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns));
+    const pattern = patterns[patternKey];
     const blockCount = supportsMultipleBlocks ? faker.datatype.number({
       min: pattern.blockCountMin,
       max: pattern.blockCountMax
@@ -1330,38 +1191,22 @@ const select = (config = {}) => {
   const faker = createFaker(config.seed);
   const model = config.model || select$1({ seed: config.seed });
   const defaultValue = model.config.default_value;
-  return typeof defaultValue === "string" && faker.datatype.boolean() ? defaultValue : faker.random.arrayElement(model.config.options);
-};
-
-const patterns$2 = {
-  none: {
-    minItems: 0,
-    maxItems: 0
-  },
-  short: {
-    minItems: 1,
-    maxItems: 3
-  },
-  medium: {
-    minItems: 3,
-    maxItems: 6
-  },
-  long: {
-    minItems: 6,
-    maxItems: 12
+  if (config.state === "empty") {
+    return null;
+  } else {
+    return typeof defaultValue === "string" && faker.datatype.boolean() ? defaultValue : faker.random.arrayElement(model.config.options);
   }
 };
+
 const slice = (config = {}) => {
-  var _a;
+  var _a, _b;
   const faker = createFaker(config.seed);
   const model = config.model || slice$1({ seed: config.seed });
-  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$2));
-  const pattern = patterns$2[patternKey];
   const sliceType = (_a = config.type) != null ? _a : generateFieldId({ seed: config.seed });
-  const sliceLabel = config.label !== void 0 ? config.label : changeCase.capitalCase(faker.company.bsNoun());
-  const itemsCount = Object.keys(model.repeat).length > 0 ? faker.datatype.number({
-    min: pattern.minItems,
-    max: pattern.maxItems
+  const sliceLabel = config.label !== void 0 ? config.label : changeCase__namespace.capitalCase(faker.company.bsNoun());
+  const itemsCount = Object.keys(model.repeat).length > 0 ? (_b = config.itemsCount) != null ? _b : faker.datatype.number({
+    min: 1,
+    max: 6
   }) : 0;
   return {
     slice_type: sliceType,
@@ -1381,39 +1226,18 @@ const slice = (config = {}) => {
   };
 };
 
-const patterns$1 = {
-  none: {
-    minItems: 0,
-    maxItems: 0
-  },
-  short: {
-    minItems: 1,
-    maxItems: 3
-  },
-  medium: {
-    minItems: 3,
-    maxItems: 6
-  },
-  long: {
-    minItems: 6,
-    maxItems: 12
-  }
-};
 const sharedSliceVariation = (config = {}) => {
   var _a, _b;
   const faker = createFaker(config.seed);
   const model = config.model || sharedSliceVariation$1({ seed: config.seed });
-  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns$1));
-  const pattern = patterns$1[patternKey];
   const sliceType = (_a = config.type) != null ? _a : generateFieldId({ seed: config.seed });
-  const sliceLabel = (_b = config.label) != null ? _b : changeCase.capitalCase(faker.company.bsNoun());
-  const itemsCount = Object.keys(model.items).length > 0 ? faker.datatype.number({
-    min: pattern.minItems,
-    max: pattern.maxItems
+  const itemsCount = Object.keys(model.items).length > 0 ? (_b = config.itemsCount) != null ? _b : faker.datatype.number({
+    min: 1,
+    max: 6
   }) : 0;
   return {
     slice_type: sliceType,
-    slice_label: sliceLabel,
+    slice_label: null,
     variation: model.id,
     version: faker.git.shortSha(),
     primary: valueForModelMap({
@@ -1438,81 +1262,102 @@ const sharedSlice = (config = {}) => {
   return sharedSliceVariation({
     seed: config.seed,
     model: variationModel,
-    pattern: config.pattern,
+    itemsCount: config.itemsCount,
     type: model.id,
     primaryFieldConfigs: config.primaryFieldConfigs,
     itemsFieldConfigs: config.itemsFieldConfigs
   });
 };
 
-const patterns = {
-  short: {
-    minItems: 1,
-    maxItems: 3
-  },
-  medium: {
-    minItems: 3,
-    maxItems: 6
-  },
-  long: {
-    minItems: 6,
-    maxItems: 12
-  }
-};
 const sliceZone = (config = {}) => {
-  const faker = createFaker(config.seed);
-  const model = config.model || sliceZone$1({ seed: config.seed });
-  const patternKey = config.pattern || faker.random.arrayElement(Object.keys(patterns));
-  const pattern = patterns[patternKey];
-  const itemsCount = faker.datatype.number({
-    min: pattern.minItems,
-    max: pattern.maxItems
-  });
-  return Array(itemsCount).fill(void 0).map(() => {
-    var _a;
-    const choices = Object.entries(model.config.choices);
-    const [choiceType, choiceModel] = faker.random.arrayElement(choices);
-    const choiceLabels = model.config.labels[choiceType] || [];
-    const choiceLabel = faker.random.arrayElement(choiceLabels);
-    switch (choiceModel.type) {
-      case prismicT.CustomTypeModelSliceType.Slice: {
-        return slice({
-          seed: config.seed,
-          model: choiceModel,
-          type: choiceType,
-          label: choiceLabel ? choiceLabel.name : null,
-          primaryFieldConfigs: config.primaryFieldConfigs,
-          itemsFieldConfigs: config.itemsFieldConfigs
-        });
-      }
-      case prismicT.CustomTypeModelSliceType.SharedSlice: {
-        const sharedSliceModel = (_a = config.sharedSliceModels) == null ? void 0 : _a.find((sharedSliceModel2) => sharedSliceModel2.id === choiceType);
-        if (sharedSliceModel) {
-          return sharedSlice({
-            seed: config.seed,
-            model: sharedSliceModel,
-            primaryFieldConfigs: config.primaryFieldConfigs,
-            itemsFieldConfigs: config.itemsFieldConfigs
-          });
+  var _a;
+  if (config.state === "empty") {
+    return [];
+  } else {
+    const faker = createFaker(config.seed);
+    const model = config.model || sliceZone$1({ seed: config.seed });
+    if (Object.keys(model.config.choices).length > 0) {
+      const itemsCount = (_a = config.itemsCount) != null ? _a : faker.datatype.number({
+        min: 1,
+        max: 6
+      });
+      return Array(itemsCount).fill(void 0).map(() => {
+        var _a2;
+        const choices = Object.entries(model.config.choices);
+        const [choiceType, choiceModel] = faker.random.arrayElement(choices);
+        const choiceLabels = model.config.labels[choiceType] || [];
+        const choiceLabel = faker.random.arrayElement(choiceLabels);
+        switch (choiceModel.type) {
+          case prismicT__namespace.CustomTypeModelSliceType.Slice: {
+            return slice({
+              seed: config.seed,
+              model: choiceModel,
+              type: choiceType,
+              label: choiceLabel ? choiceLabel.name : null,
+              primaryFieldConfigs: config.primaryFieldConfigs,
+              itemsFieldConfigs: config.itemsFieldConfigs
+            });
+          }
+          case prismicT__namespace.CustomTypeModelSliceType.SharedSlice: {
+            const sharedSliceModel = (_a2 = config.sharedSliceModels) == null ? void 0 : _a2.find((sharedSliceModel2) => sharedSliceModel2.id === choiceType);
+            if (sharedSliceModel) {
+              return sharedSlice({
+                seed: config.seed,
+                model: sharedSliceModel,
+                primaryFieldConfigs: config.primaryFieldConfigs,
+                itemsFieldConfigs: config.itemsFieldConfigs
+              });
+            }
+          }
         }
-      }
+      }).filter((slice2) => slice2 !== void 0);
+    } else {
+      return [];
     }
-  }).filter((slice2) => slice2 !== void 0);
+  }
 };
 
 const title = (config = {}) => {
-  return [
-    heading({
-      seed: config.seed,
-      model: config.model,
-      pattern: config.pattern
-    })
-  ];
+  if (config.state === "empty") {
+    return [];
+  } else {
+    return [
+      heading({
+        seed: config.seed,
+        model: config.model,
+        pattern: config.pattern
+      })
+    ];
+  }
 };
 
 const uid = (config = {}) => {
   const faker = createFaker(config.seed);
-  return changeCase.snakeCase(faker.lorem.words(2));
-};
-
-export { boolean$1 as boolean, color, contentRelationship, customType, date, customType as document, embed$1 as embed, geoPoint, group, image$1 as image, integrationFields, keyText, link, linkToMedia, number, richText, select, sharedSlice, sharedSliceVariation, slice, sliceZone, timestamp, title, uid };
+  return changeCase__namespace.snakeCase(faker.lorem.words(2));
+};
+
+exports.boolean = boolean;
+exports.color = color;
+exports.contentRelationship = contentRelationship;
+exports.customType = customType;
+exports.date = date;
+exports.document = customType;
+exports.embed = embed$1;
+exports.geoPoint = geoPoint;
+exports.group = group;
+exports.image = image$1;
+exports.integrationFields = integrationFields;
+exports.keyText = keyText;
+exports.link = link;
+exports.linkToMedia = linkToMedia;
+exports.number = number;
+exports.richText = richText;
+exports.select = select;
+exports.sharedSlice = sharedSlice;
+exports.sharedSliceVariation = sharedSliceVariation;
+exports.slice = slice;
+exports.sliceZone = sliceZone;
+exports.timestamp = timestamp;
+exports.title = title;
+exports.uid = uid;
+//# sourceMappingURL=index.js.map