@prismicio/mock 0.0.3 → 0.0.7

package/dist/model/index.d.ts

@@ -1,8 +1,10 @@
 import * as prismicT from '@prismicio/types';
 
+declare type Seed = string | number | number[];
 declare type MockModelConfig = {
-    seed?: number;
+    seed?: Seed;
 };
+declare type GroupFieldModelMap = Record<string, prismicT.CustomTypeModelFieldForGroup>;
 
 declare type MockBooleanModelConfig = MockModelConfig;
 declare const boolean: (config?: MockBooleanModelConfig) => prismicT.CustomTypeModelBooleanField;
@@ -10,80 +12,26 @@ declare const boolean: (config?: MockBooleanModelConfig) => prismicT.CustomTypeM
 declare type MockColorModelConfig = MockModelConfig;
 declare const color: (config?: MockColorModelConfig) => prismicT.CustomTypeModelColorField;
 
-declare type MockContentRelationshipModelConfig = {
-    constrainCustomTypes?: boolean;
-    constrainTags?: boolean;
+declare type MockContentRelationshipModelConfig<CustomTypeIDs extends string = string, Tags extends string = string> = {
+    customTypeIDs?: readonly CustomTypeIDs[];
+    tags?: readonly Tags[];
 } & MockModelConfig;
-declare const contentRelationship: (config?: MockContentRelationshipModelConfig) => prismicT.CustomTypeModelContentRelationshipField;
+declare const contentRelationship: <CustomTypeIDs extends string, Tags extends string>(config?: MockContentRelationshipModelConfig<CustomTypeIDs, Tags>) => prismicT.CustomTypeModelContentRelationshipField<CustomTypeIDs, Tags>;
 
-declare type MockRichTextModelConfig<WithMultipleBlocks extends boolean = boolean> = {
-    withMultipleBlocks?: WithMultipleBlocks;
-} & MockModelConfig;
-declare const richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
-
-declare type MockLinkModel<AllowTargetBlank extends boolean = boolean> = prismicT.CustomTypeModelLinkField & {
-    config: AllowTargetBlank extends true ? {
-        allowTargetBlank: true;
-    } : {
-        allowTargetBlank?: undefined;
-    };
-};
-declare type MockLinkModelConfig<AllowTargetBlank extends boolean = boolean> = {
-    allowTargetBlank?: AllowTargetBlank;
-} & MockModelConfig;
-declare const link: <AllowTargetBlank extends boolean = boolean>(config?: MockLinkModelConfig<AllowTargetBlank>) => MockLinkModel<AllowTargetBlank>;
-
-declare const mockModelFns: {
-    readonly boolean: (config?: MockModelConfig) => prismicT.CustomTypeModelBooleanField;
-    readonly color: (config?: MockModelConfig) => prismicT.CustomTypeModelColorField;
-    readonly contentRelationship: (config?: MockContentRelationshipModelConfig) => prismicT.CustomTypeModelContentRelationshipField;
-    readonly date: (config?: MockModelConfig) => prismicT.CustomTypeModelDateField;
-    readonly embed: (config?: MockModelConfig) => prismicT.CustomTypeModelEmbedField;
-    readonly geoPoint: (config?: MockModelConfig) => prismicT.CustomTypeModelGeoPointField;
-    readonly image: (config?: {
-        withConstraint?: boolean | undefined;
-        thumbnailsCount?: number | undefined;
-    } & MockModelConfig) => prismicT.CustomTypeModelImageField;
-    readonly integrationFields: (config?: MockModelConfig) => prismicT.CustomTypeModelIntegrationFieldsField;
-    readonly keyText: (config?: MockModelConfig) => prismicT.CustomTypeModelKeyTextField;
-    readonly link: <AllowTargetBlank extends boolean = boolean>(config?: MockLinkModelConfig<AllowTargetBlank>) => prismicT.CustomTypeModelLinkField & {
-        config: AllowTargetBlank extends true ? {
-            allowTargetBlank: true;
-        } : {
-            allowTargetBlank?: undefined;
-        };
-    };
-    readonly linkToMedia: (config?: MockModelConfig) => prismicT.CustomTypeModelLinkToMediaField;
-    readonly number: (config?: MockModelConfig) => prismicT.CustomTypeModelNumberField;
-    readonly richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
-    readonly select: (config?: {
-        optionsCount?: number | undefined;
-        withDefaultValue?: boolean | undefined;
-    } & MockModelConfig) => prismicT.CustomTypeModelSelectField<string, string>;
-    readonly timestamp: (config?: MockModelConfig) => prismicT.CustomTypeModelTimestampField;
-    readonly title: (config?: MockModelConfig) => prismicT.CustomTypeModelRichTextSingleField;
-};
-declare type MockModelFns = typeof mockModelFns;
-declare type BuildMockGroupFieldMapConfig = {
-    configs?: {
-        [P in keyof MockModelFns]?: {
-            count?: number;
-            config?: Parameters<MockModelFns[P]>[0];
-        };
-    };
-} & MockModelConfig;
-
-declare type MockCustomTypeModelConfig = {
-    tabsCount?: number;
-    withUID?: boolean;
-    configs?: BuildMockGroupFieldMapConfig["configs"];
+declare type MockCustomTypeModelConfig<Definition extends prismicT.CustomTypeModelTab | prismicT.CustomTypeModelDefinition = prismicT.CustomTypeModelTab | prismicT.CustomTypeModelDefinition> = {
+    id?: string;
+    label?: string;
+    status?: boolean;
+    repeatable?: boolean;
 } & ({
-    withSliceZones?: false;
+    fields?: Definition;
+    tabs?: never;
 } | {
-    withSliceZones: true;
-    withSharedSlices?: boolean;
+    tabs?: Definition;
+    fields?: never;
 }) & MockModelConfig;
-declare const customType: (config?: MockCustomTypeModelConfig) => prismicT.CustomTypeModel;
+declare type MockCustomTypeModel<Definition extends prismicT.CustomTypeModelTab | prismicT.CustomTypeModelDefinition> = Definition extends prismicT.CustomTypeModelTab ? prismicT.CustomTypeModel<string, Record<"Main", Definition>> : Definition extends prismicT.CustomTypeModelDefinition ? prismicT.CustomTypeModel<string, Definition> : never;
+declare const customType: <Definition extends Record<string, prismicT.CustomTypeModelField> | prismicT.CustomTypeModelDefinition<string>>(config?: MockCustomTypeModelConfig<Definition>) => MockCustomTypeModel<Definition>;
 
 declare type MockDateModelConfig = MockModelConfig;
 declare const date: (config?: MockDateModelConfig) => prismicT.CustomTypeModelDateField;
@@ -94,14 +42,16 @@ declare const embed: (config?: MockEmbedModelConfig) => prismicT.CustomTypeModel
 declare type MockGeoPointModelConfig = MockModelConfig;
 declare const geoPoint: (config?: MockGeoPointModelConfig) => prismicT.CustomTypeModelGeoPointField;
 
-declare type MockGroupModelConfig = BuildMockGroupFieldMapConfig & MockModelConfig;
-declare const group: (config?: MockGroupModelConfig) => prismicT.CustomTypeModelGroupField;
+declare type MockGroupModelConfig<Fields extends GroupFieldModelMap> = {
+    fields?: Fields;
+} & MockModelConfig;
+declare const group: <Fields extends GroupFieldModelMap>(config?: MockGroupModelConfig<Fields>) => prismicT.CustomTypeModelGroupField<Fields>;
 
-declare type MockImageModelConfig = {
+declare type MockImageModelConfig<ThumbnailNames extends string = string> = {
     withConstraint?: boolean;
-    thumbnailsCount?: number;
+    thumbnailNames?: readonly ThumbnailNames[];
 } & MockModelConfig;
-declare const image: (config?: MockImageModelConfig) => prismicT.CustomTypeModelImageField;
+declare const image: <ThumbnailNames extends string = string>(config?: MockImageModelConfig<ThumbnailNames>) => prismicT.CustomTypeModelImageField<ThumbnailNames>;
 
 declare type MockIntegrationFieldsModelConfig = MockModelConfig;
 declare const integrationFields: (config?: MockIntegrationFieldsModelConfig) => prismicT.CustomTypeModelIntegrationFieldsField;
@@ -109,42 +59,62 @@ declare const integrationFields: (config?: MockIntegrationFieldsModelConfig) =>
 declare type MockKeyTextModelConfig = MockModelConfig;
 declare const keyText: (config?: MockKeyTextModelConfig) => prismicT.CustomTypeModelKeyTextField;
 
+declare type MockLinkModel<AllowTargetBlank extends boolean = boolean> = prismicT.CustomTypeModelLinkField & {
+    config: AllowTargetBlank extends true ? {
+        allowTargetBlank: true;
+    } : {
+        allowTargetBlank?: undefined;
+    };
+};
+declare type MockLinkModelConfig<AllowTargetBlank extends boolean = boolean> = {
+    allowTargetBlank?: AllowTargetBlank;
+} & MockModelConfig;
+declare const link: <AllowTargetBlank extends boolean = boolean>(config?: MockLinkModelConfig<AllowTargetBlank>) => MockLinkModel<AllowTargetBlank>;
+
 declare type MockLinkTomediaModelConfig = MockModelConfig;
 declare const linkToMedia: (config?: MockLinkTomediaModelConfig) => prismicT.CustomTypeModelLinkToMediaField;
 
 declare type MockNumberModelConfig = MockModelConfig;
 declare const number: (config?: MockNumberModelConfig) => prismicT.CustomTypeModelNumberField;
 
-declare type MockSelectModelConfig = {
-    optionsCount?: number;
-    withDefaultValue?: boolean;
+declare type MockRichTextModelConfig<WithMultipleBlocks extends boolean = boolean> = {
+    withMultipleBlocks?: WithMultipleBlocks;
 } & MockModelConfig;
-declare const select: (config?: MockSelectModelConfig) => prismicT.CustomTypeModelSelectField;
+declare const richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
 
-declare type MockSharedSliceVariationModelConfig = {
-    primaryFieldConfig?: BuildMockGroupFieldMapConfig;
-    itemsFieldConfig?: BuildMockGroupFieldMapConfig;
+declare type MockSelectModelConfig<Option extends string = string, DefaultOption extends Option = Option> = {
+    options?: Option[];
+    defaultValue?: DefaultOption;
 } & MockModelConfig;
-declare const sharedSliceVariation: (config?: MockSharedSliceVariationModelConfig) => prismicT.SharedSliceModelVariation;
+declare const select: <Option extends string, DefaultOption extends Option>(config?: MockSelectModelConfig<Option, DefaultOption>) => prismicT.CustomTypeModelSelectField<Option, DefaultOption>;
 
-declare type MockSharedSliceModelConfig = {
-    variationsCount?: number;
-} & Pick<MockSharedSliceVariationModelConfig, "itemsFieldConfig" | "primaryFieldConfig"> & MockModelConfig;
-declare const sharedSlice: (config?: MockSharedSliceModelConfig) => prismicT.SharedSliceModel;
+declare type MockSharedSliceModelConfig<Variation extends prismicT.SharedSliceModelVariation> = {
+    id?: string;
+    name?: string;
+    variations?: Variation[];
+} & MockModelConfig;
+declare const sharedSlice: <Variation extends prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceModelConfig<Variation>) => prismicT.SharedSliceModel<string, Variation>;
 
 declare const sharedSliceChoice: () => prismicT.CustomTypeModelSharedSlice;
 
-declare type MockSliceModelConfig = {
-    repeatFieldConfig?: BuildMockGroupFieldMapConfig;
-    nonRepeatFieldConfig?: BuildMockGroupFieldMapConfig;
+declare type MockSharedSliceVariationModelConfig<ID extends string = string, PrimaryFields extends GroupFieldModelMap = GroupFieldModelMap, ItemsFields extends GroupFieldModelMap = GroupFieldModelMap> = {
+    id?: ID;
+    name?: string;
+    primaryFields?: PrimaryFields;
+    itemsFields?: ItemsFields;
 } & MockModelConfig;
-declare const slice: (config?: MockSliceModelConfig) => prismicT.CustomTypeModelSlice;
+declare const sharedSliceVariation: <ID extends string, PrimaryFields extends GroupFieldModelMap, ItemsFields extends GroupFieldModelMap>(config?: MockSharedSliceVariationModelConfig<ID, PrimaryFields, ItemsFields>) => prismicT.SharedSliceModelVariation<ID, PrimaryFields, ItemsFields>;
 
-declare type MockSliceZoneModelConfig = {
-    choicesCount?: number;
-    withSharedSlices?: boolean;
+declare type MockSliceModelConfig<NonRepeatFields extends GroupFieldModelMap = GroupFieldModelMap, RepeatFields extends GroupFieldModelMap = GroupFieldModelMap> = {
+    nonRepeatFields?: NonRepeatFields;
+    repeatFields?: RepeatFields;
 } & MockModelConfig;
-declare const sliceZone: (config?: MockSliceZoneModelConfig) => prismicT.CustomTypeModelSliceZoneField;
+declare const slice: <NonRepeatFields extends GroupFieldModelMap, RepeatFields extends GroupFieldModelMap>(config?: MockSliceModelConfig<NonRepeatFields, RepeatFields>) => prismicT.CustomTypeModelSlice<NonRepeatFields, RepeatFields>;
+
+declare type MockSliceZoneModelConfig<Slices extends Record<string, prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice> = Record<string, prismicT.CustomTypeModelSlice | prismicT.CustomTypeModelSharedSlice>> = {
+    choices?: Slices;
+} & MockModelConfig;
+declare const sliceZone: <Slices extends Record<string, prismicT.CustomTypeModelSlice<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> | prismicT.CustomTypeModelSharedSlice>>(config?: MockSliceZoneModelConfig<Slices>) => prismicT.CustomTypeModelSliceZoneField<Slices>;
 
 declare type MockTimestampModelConfig = MockModelConfig;
 declare const timestamp: (config?: MockTimestampModelConfig) => prismicT.CustomTypeModelTimestampField;
@@ -155,4 +125,8 @@ declare const title: (config?: MockTitleModelConfig) => prismicT.CustomTypeModel
 declare type MockUIDModelConfig = MockModelConfig;
 declare const uid: (config?: MockUIDModelConfig) => prismicT.CustomTypeModelUIDField;
 
-export { boolean, color, contentRelationship, customType, date, embed, geoPoint, group, image, integrationFields, keyText, link, linkToMedia, number, richText, select, sharedSlice, sharedSliceChoice, sharedSliceVariation, slice, sliceZone, timestamp, title, uid };
+declare type BuildMockGroupFieldMapConfig = MockModelConfig;
+declare const buildMockGroupFieldMap: (config?: BuildMockGroupFieldMapConfig) => GroupFieldModelMap;
+
+export { boolean, buildMockGroupFieldMap, color, contentRelationship, customType, date, embed, geoPoint, group, image, integrationFields, keyText, link, linkToMedia, number, richText, select, sharedSlice, sharedSliceChoice, sharedSliceVariation, slice, sliceZone, timestamp, title, uid };
+//# sourceMappingURL=index.d.ts.map

package/dist/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/model/index.js

@@ -0,0 +1,462 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const prismicT = require('@prismicio/types');
+const changeCase = require('change-case');
+const fakerLocaleEN = require('faker/lib/locales/en/index.js');
+const Faker = require('faker/lib/index.js');
+
+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 prismicT__namespace = /*#__PURE__*/_interopNamespace(prismicT);
+const changeCase__namespace = /*#__PURE__*/_interopNamespace(changeCase);
+const fakerLocaleEN__namespace = /*#__PURE__*/_interopNamespace(fakerLocaleEN);
+const Faker__default = /*#__PURE__*/_interopDefaultLegacy(Faker);
+
+const FAKER_SEED = 1984;
+
+const createFaker = (seed = FAKER_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 fakerInstance = new Faker__default["default"]();
+  fakerInstance.locales["en"] = fakerLocaleEN__namespace;
+  fakerInstance.seed(normalizedSeed);
+  createFaker.cache[cacheKey] = fakerInstance;
+  return fakerInstance;
+};
+createFaker.cache = {};
+
+const boolean = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Boolean,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun())
+    }
+  };
+};
+
+const color = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Color,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3))
+    }
+  };
+};
+
+const contentRelationship = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Link,
+    config: {
+      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 customType = (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 {
+    id,
+    label,
+    status: (_a = config.status) != null ? _a : faker.datatype.boolean(),
+    repeatable: (_b = config.repeatable) != null ? _b : faker.datatype.boolean(),
+    json
+  };
+};
+
+const date = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Date,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3))
+    }
+  };
+};
+
+const embed = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Embed,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3))
+    }
+  };
+};
+
+const geoPoint = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.GeoPoint,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun())
+    }
+  };
+};
+
+const group = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Group,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      fields: config.fields || {}
+    }
+  };
+};
+
+const image = (config = {}) => {
+  const faker = createFaker(config.seed);
+  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__namespace.CustomTypeModelFieldType.Image,
+    config: {
+      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
+    }
+  };
+};
+
+const integrationFields = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.IntegrationFields,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      catalog: changeCase__namespace.snakeCase(faker.lorem.words(4))
+    }
+  };
+};
+
+const keyText = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Text,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3))
+    }
+  };
+};
+
+const link = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Link,
+    config: {
+      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 = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Link,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3)),
+      select: prismicT__namespace.CustomTypeModelLinkSelectType.Media
+    }
+  };
+};
+
+const number = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Number,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3))
+    }
+  };
+};
+
+const richText = (config = {}) => {
+  var _a;
+  const faker = createFaker(config.seed);
+  const blockTypes = faker.random.arrayElements([
+    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__namespace.CustomTypeModelFieldType.StructuredText,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3)),
+      allowTargetBlank: faker.datatype.boolean() ? true : void 0,
+      ...blockTypeConfig
+    }
+  };
+};
+
+const select = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Select,
+    config: {
+      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 sharedSlice = (config = {}) => {
+  const faker = createFaker(config.seed);
+  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__namespace.CustomTypeModelSliceType.SharedSlice,
+    id,
+    name,
+    description: faker.lorem.sentence(),
+    variations: config.variations || []
+  };
+};
+
+const sharedSliceChoice = () => {
+  return {
+    type: prismicT__namespace.CustomTypeModelSliceType.SharedSlice
+  };
+};
+
+const sharedSliceVariation = (config = {}) => {
+  const faker = createFaker(config.seed);
+  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 {
+    id,
+    name,
+    description: faker.lorem.sentence(),
+    docURL: faker.internet.url(),
+    version: faker.git.shortSha(),
+    primary: config.primaryFields || {},
+    items: config.itemsFields || {}
+  };
+};
+
+const slice = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    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: config.repeatFields || {},
+    "non-repeat": config.nonRepeatFields || {}
+  };
+};
+
+const sliceZone = (config = {}) => {
+  const labels = {};
+  for (const choiceId in config.choices) {
+    const choice = config.choices[choiceId];
+    if (choice.type === prismicT__namespace.CustomTypeModelSliceType.Slice) {
+      labels[choiceId] = [];
+    }
+  }
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Slices,
+    fieldset: "Slice zone",
+    config: {
+      labels,
+      choices: config.choices || {}
+    }
+  };
+};
+
+const timestamp = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.Timestamp,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3))
+    }
+  };
+};
+
+const title = (config = {}) => {
+  const faker = createFaker(config.seed);
+  const single = faker.random.arrayElements([
+    "heading1",
+    "heading2",
+    "heading3",
+    "heading4",
+    "heading5",
+    "heading6"
+  ]).join(",");
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.StructuredText,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3)),
+      single,
+      allowTargetBlank: faker.datatype.boolean() ? true : void 0
+    }
+  };
+};
+
+const uid = (config = {}) => {
+  const faker = createFaker(config.seed);
+  return {
+    type: prismicT__namespace.CustomTypeModelFieldType.UID,
+    config: {
+      label: changeCase__namespace.capitalCase(faker.company.bsNoun()),
+      placeholder: changeCase__namespace.sentenceCase(faker.lorem.words(3))
+    }
+  };
+};
+
+const generateFieldId = (config) => {
+  const faker = createFaker(config.seed);
+  return changeCase__namespace.snakeCase(faker.lorem.words(faker.datatype.number({ min: 1, max: 3 })));
+};
+
+const mockModelFns = {
+  boolean,
+  color,
+  contentRelationship,
+  date,
+  embed,
+  geoPoint,
+  image,
+  integrationFields,
+  keyText,
+  link,
+  linkToMedia,
+  number,
+  richText,
+  select,
+  timestamp,
+  title
+};
+const buildMockGroupFieldMap = (config = {}) => {
+  const faker = createFaker(config.seed);
+  const fields = {};
+  const fieldTypes = faker.random.arrayElements(Object.keys(mockModelFns));
+  for (const fieldType of fieldTypes) {
+    const fieldId = generateFieldId({ seed: config.seed });
+    const mockModelFn = mockModelFns[fieldType];
+    fields[fieldId] = mockModelFn({ seed: config.seed });
+  }
+  return fields;
+};
+
+exports.boolean = boolean;
+exports.buildMockGroupFieldMap = buildMockGroupFieldMap;
+exports.color = color;
+exports.contentRelationship = contentRelationship;
+exports.customType = customType;
+exports.date = date;
+exports.embed = embed;
+exports.geoPoint = geoPoint;
+exports.group = group;
+exports.image = image;
+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.sharedSliceChoice = sharedSliceChoice;
+exports.sharedSliceVariation = sharedSliceVariation;
+exports.slice = slice;
+exports.sliceZone = sliceZone;
+exports.timestamp = timestamp;
+exports.title = title;
+exports.uid = uid;
+//# sourceMappingURL=index.js.map