@prismicio/mock 0.7.0 → 0.7.1-canary.b078d42

package/src/value/sharedSlice.ts

@@ -1,14 +1,12 @@
-import * as prismic from "@prismicio/client";
+import type * as prismic from "@prismicio/client"
 
-import { createFaker } from "../lib/createFaker";
-
-import { MockValueConfig, ModelValue } from "../types";
-
-import * as modelGen from "../model";
+import { createFaker } from "../lib/createFaker"
+import * as modelGen from "../model"
+import type { MockValueConfig, ModelValue } from "../types"
 import {
 	sharedSliceVariation,
-	MockSharedSliceVariationValueConfig,
-} from "./sharedSliceVariation";
+	type MockSharedSliceVariationValueConfig,
+} from "./sharedSliceVariation"
 
 export type MockSharedSliceValueConfig<
 	Model extends prismic.SharedSliceModel = prismic.SharedSliceModel,
@@ -16,17 +14,15 @@ export type MockSharedSliceValueConfig<
 	MockSharedSliceVariationValueConfig,
 	"itemsCount" | "primaryFieldConfigs" | "itemsFieldConfigs"
 > &
-	MockValueConfig<Model>;
+	MockValueConfig<Model>
 
-export const sharedSlice = <
-	Model extends prismic.SharedSliceModel = prismic.SharedSliceModel,
->(
+export const sharedSlice = <Model extends prismic.SharedSliceModel = prismic.SharedSliceModel>(
 	config: MockSharedSliceValueConfig<Model>,
 ): ModelValue<Model> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
-	const model = config.model || modelGen.sharedSlice({ faker });
-	const variationModel = faker.randomElement(model.variations);
+	const model = config.model || modelGen.sharedSlice({ faker })
+	const variationModel = faker.randomElement(model.variations)
 
 	return sharedSliceVariation({
 		faker,
@@ -35,5 +31,5 @@ export const sharedSlice = <
 		type: model.id,
 		primaryFieldConfigs: config.primaryFieldConfigs,
 		itemsFieldConfigs: config.itemsFieldConfigs,
-	}) as ModelValue<Model>;
-};
+	}) as ModelValue<Model>
+}

package/src/value/sharedSliceVariation.ts

@@ -1,43 +1,36 @@
-import * as prismic from "@prismicio/client";
+import type * as prismic from "@prismicio/client"
 
-import { MockValueConfig, ModelValue } from "../types";
-
-import { createFaker } from "../lib/createFaker";
-import { generateFieldId } from "../lib/generateFieldId";
-import {
-	valueForModelMap,
-	ValueForModelMapConfigs,
-} from "../lib/valueForModelMap";
-
-import * as modelGen from "../model";
+import { createFaker } from "../lib/createFaker"
+import { generateFieldId } from "../lib/generateFieldId"
+import { valueForModelMap, type ValueForModelMapConfigs } from "../lib/valueForModelMap"
+import * as modelGen from "../model"
+import type { MockValueConfig, ModelValue } from "../types"
 
 export type MockSharedSliceVariationValueConfig<
-	Model extends
-		prismic.SharedSliceModelVariation = prismic.SharedSliceModelVariation,
+	Model extends prismic.SharedSliceModelVariation = prismic.SharedSliceModelVariation,
 > = {
-	type?: string;
-	label?: string;
-	itemsCount?: number;
-	primaryFieldConfigs?: ValueForModelMapConfigs;
-	itemsFieldConfigs?: ValueForModelMapConfigs;
-} & MockValueConfig<Model>;
+	type?: string
+	label?: string
+	itemsCount?: number
+	primaryFieldConfigs?: ValueForModelMapConfigs
+	itemsFieldConfigs?: ValueForModelMapConfigs
+} & MockValueConfig<Model>
 
 export const sharedSliceVariation = <
-	Model extends
-		prismic.SharedSliceModelVariation = prismic.SharedSliceModelVariation,
+	Model extends prismic.SharedSliceModelVariation = prismic.SharedSliceModelVariation,
 >(
 	config: MockSharedSliceVariationValueConfig<Model>,
 ): ModelValue<Model> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
-	const model = config.model || modelGen.sharedSliceVariation({ faker });
+	const model = config.model || modelGen.sharedSliceVariation({ faker })
 
-	const sliceType = config.type ?? generateFieldId({ faker });
+	const sliceType = config.type ?? generateFieldId({ faker })
 
 	const itemsCount =
 		model.items && Object.keys(model.items).length > 0
-			? config.itemsCount ?? faker.range(1, 6)
-			: 0;
+			? (config.itemsCount ?? faker.range(1, 6))
+			: 0
 
 	return {
 		id: faker.hash(11),
@@ -57,7 +50,7 @@ export const sharedSliceVariation = <
 					faker,
 					map: model.items || {},
 					configs: config.itemsFieldConfigs,
-				});
+				})
 			}),
-	} as ModelValue<Model>;
-};
+	} as ModelValue<Model>
+}

package/src/value/slice.ts

@@ -1,46 +1,37 @@
-import * as prismic from "@prismicio/client";
+import type * as prismic from "@prismicio/client"
 
-import { MockValueConfig, ModelValue } from "../types";
-
-import { capitalCase } from "../lib/changeCase";
-import { createFaker } from "../lib/createFaker";
-import { generateFieldId } from "../lib/generateFieldId";
-import {
-	valueForModelMap,
-	ValueForModelMapConfigs,
-} from "../lib/valueForModelMap";
-
-import * as modelGen from "../model";
+import { capitalCase } from "../lib/changeCase"
+import { createFaker } from "../lib/createFaker"
+import { generateFieldId } from "../lib/generateFieldId"
+import { valueForModelMap, type ValueForModelMapConfigs } from "../lib/valueForModelMap"
+import * as modelGen from "../model"
+import type { MockValueConfig, ModelValue } from "../types"
 
 export type MockSliceValueConfig<
 	Model extends prismic.CustomTypeModelSlice = prismic.CustomTypeModelSlice,
 > = {
-	type?: string;
-	label?: string | null;
-	itemsCount?: number;
-	primaryFieldConfigs?: ValueForModelMapConfigs;
-	itemsFieldConfigs?: ValueForModelMapConfigs;
-} & MockValueConfig<Model>;
-
-export const slice = <
-	Model extends prismic.CustomTypeModelSlice = prismic.CustomTypeModelSlice,
->(
+	type?: string
+	label?: string | null
+	itemsCount?: number
+	primaryFieldConfigs?: ValueForModelMapConfigs
+	itemsFieldConfigs?: ValueForModelMapConfigs
+} & MockValueConfig<Model>
+
+export const slice = <Model extends prismic.CustomTypeModelSlice = prismic.CustomTypeModelSlice>(
 	config: MockSliceValueConfig<Model>,
 ): ModelValue<Model> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
-	const model = config.model || modelGen.slice({ faker });
+	const model = config.model || modelGen.slice({ faker })
 
-	const sliceType = config.type ?? generateFieldId({ faker });
+	const sliceType = config.type ?? generateFieldId({ faker })
 	const sliceLabel =
-		config.label !== undefined
-			? config.label
-			: capitalCase(faker.words(faker.range(1, 2)));
+		config.label !== undefined ? config.label : capitalCase(faker.words(faker.range(1, 2)))
 
 	const itemsCount =
 		model.repeat && Object.keys(model.repeat).length > 0
-			? config.itemsCount ?? faker.range(1, 6)
-			: 0;
+			? (config.itemsCount ?? faker.range(1, 6))
+			: 0
 
 	return {
 		id: faker.hash(11),
@@ -58,7 +49,7 @@ export const slice = <
 					faker,
 					map: model.repeat || {},
 					configs: config.itemsFieldConfigs,
-				});
+				})
 			}),
-	} as ModelValue<Model>;
-};
+	} as ModelValue<Model>
+}

package/src/value/sliceZone.ts

@@ -1,54 +1,47 @@
-import * as prismic from "@prismicio/client";
+import * as prismic from "@prismicio/client"
 
-import { createFaker } from "../lib/createFaker";
-import { ValueForModelMapConfigs } from "../lib/valueForModelMap";
-
-import { MockValueConfig, MockValueStateConfig, ModelValue } from "../types";
-
-import * as modelGen from "../model";
-
-import { slice } from "./slice";
-import { sharedSlice } from "./sharedSlice";
+import { createFaker } from "../lib/createFaker"
+import type { ValueForModelMapConfigs } from "../lib/valueForModelMap"
+import * as modelGen from "../model"
+import type { MockValueConfig, MockValueStateConfig, ModelValue } from "../types"
+import { sharedSlice } from "./sharedSlice"
+import { slice } from "./slice"
 
 export type MockSliceZoneValueConfig<
-	Model extends
-		prismic.CustomTypeModelSliceZoneField = prismic.CustomTypeModelSliceZoneField,
+	Model extends prismic.CustomTypeModelSliceZoneField = prismic.CustomTypeModelSliceZoneField,
 	State extends prismic.FieldState = prismic.FieldState,
 > = {
-	sharedSliceModels?: prismic.SharedSliceModel[];
-	itemsCount?: State extends "empty" ? 0 : number;
-	primaryFieldConfigs?: ValueForModelMapConfigs;
-	itemsFieldConfigs?: ValueForModelMapConfigs;
+	sharedSliceModels?: prismic.SharedSliceModel[]
+	itemsCount?: State extends "empty" ? 0 : number
+	primaryFieldConfigs?: ValueForModelMapConfigs
+	itemsFieldConfigs?: ValueForModelMapConfigs
 } & MockValueConfig<Model> &
-	MockValueStateConfig<State>;
+	MockValueStateConfig<State>
 
 export const sliceZone = <
-	Model extends
-		prismic.CustomTypeModelSliceZoneField = prismic.CustomTypeModelSliceZoneField,
+	Model extends prismic.CustomTypeModelSliceZoneField = prismic.CustomTypeModelSliceZoneField,
 	State extends prismic.FieldState = prismic.FieldState,
 >(
 	config: MockSliceZoneValueConfig<Model, State>,
 ): ModelValue<Model, State> => {
 	if (config.state === "empty") {
-		return [] as ModelValue<Model, State>;
+		return [] as ModelValue<Model, State>
 	} else {
-		const faker = config.faker || createFaker(config.seed);
+		const faker = config.faker || createFaker(config.seed)
 
-		const model = config.model || modelGen.sliceZone({ faker });
+		const model = config.model || modelGen.sliceZone({ faker })
 
 		if (model.config?.choices && Object.keys(model.config.choices).length > 0) {
-			const itemsCount = config.itemsCount ?? faker.range(1, 6);
+			const itemsCount = config.itemsCount ?? faker.range(1, 6)
 
 			return Array(itemsCount)
 				.fill(undefined)
 				.map(() => {
-					const choices =
-						(model.config?.choices && Object.entries(model.config.choices)) ||
-						[];
-					const [choiceType, choiceModel] = faker.randomElement(choices);
+					const choices = (model.config?.choices && Object.entries(model.config.choices)) || []
+					const [choiceType, choiceModel] = faker.randomElement(choices)
 
-					const choiceLabels = model.config?.labels?.[choiceType] || [];
-					const choiceLabel = faker.randomElement(choiceLabels);
+					const choiceLabels = model.config?.labels?.[choiceType] || []
+					const choiceLabel = faker.randomElement(choiceLabels)
 
 					switch (choiceModel.type) {
 						case prismic.CustomTypeModelSliceType.Slice: {
@@ -59,13 +52,13 @@ export const sliceZone = <
 								label: choiceLabel ? choiceLabel.name : null,
 								primaryFieldConfigs: config.primaryFieldConfigs,
 								itemsFieldConfigs: config.itemsFieldConfigs,
-							});
+							})
 						}
 
 						case prismic.CustomTypeModelSliceType.SharedSlice: {
 							const sharedSliceModel = config.sharedSliceModels?.find(
 								(sharedSliceModel) => sharedSliceModel.id === choiceType,
-							);
+							)
 
 							if (sharedSliceModel) {
 								return sharedSlice({
@@ -73,16 +66,17 @@ export const sliceZone = <
 									model: sharedSliceModel,
 									primaryFieldConfigs: config.primaryFieldConfigs,
 									itemsFieldConfigs: config.itemsFieldConfigs,
-								});
+								})
 							}
 						}
 					}
 				})
-				.filter(
-					(slice): slice is NonNullable<typeof slice> => slice !== undefined,
-				) as ModelValue<Model, State>;
+				.filter((slice): slice is NonNullable<typeof slice> => slice !== undefined) as ModelValue<
+				Model,
+				State
+			>
 		} else {
-			return [] as unknown as ModelValue<Model, State>;
+			return [] as unknown as ModelValue<Model, State>
 		}
 	}
-};
+}

package/src/value/table.ts

@@ -1,31 +1,27 @@
-import * as prismic from "@prismicio/client";
+import * as prismic from "@prismicio/client"
 
-import { createFaker, Faker } from "../lib/createFaker";
-
-import { MockValueStateConfig, MockValueConfig } from "../types";
-import { richText } from "./richText";
+import { createFaker, type Faker } from "../lib/createFaker"
+import type { MockValueStateConfig, MockValueConfig } from "../types"
+import { richText } from "./richText"
 
 export type MockTableValueConfig<
-	Model extends
-		prismic.CustomTypeModelTableField = prismic.CustomTypeModelTableField,
+	Model extends prismic.CustomTypeModelTableField = prismic.CustomTypeModelTableField,
 	State extends prismic.FieldState = prismic.FieldState,
-> = MockValueConfig<Model> & MockValueStateConfig<State>;
+> = MockValueConfig<Model> & MockValueStateConfig<State>
 
-export type MockTableValue<
-	State extends prismic.FieldState = prismic.FieldState,
-> = prismic.TableField<State>;
+export type MockTableValue<State extends prismic.FieldState = prismic.FieldState> =
+	prismic.TableField<State>
 
 export const table = <
-	Model extends
-		prismic.CustomTypeModelTableField = prismic.CustomTypeModelTableField,
+	Model extends prismic.CustomTypeModelTableField = prismic.CustomTypeModelTableField,
 	State extends prismic.FieldState = "filled",
 >(
 	config: MockTableValueConfig<Model, State>,
 ): MockTableValue<State> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
-	const cells = faker.range(1, 10);
-	const bodyRows = faker.range(1, 10);
+	const cells = faker.range(1, 10)
+	const bodyRows = faker.range(1, 10)
 
 	return (
 		config.state === "empty"
@@ -54,8 +50,8 @@ export const table = <
 						})),
 					},
 				}
-	) as MockTableValue<State>;
-};
+	) as MockTableValue<State>
+}
 
 // Only exported for testing purposes, to ensure the model used is in sync with the internal one.
 export const TableCell = {
@@ -68,18 +64,12 @@ export const TableCell = {
 			prismic.RichTextNodeType.hyperlink,
 		].join(","),
 	},
-} as const;
+} as const
 
-const mockTableCell = ({
-	type,
-	faker,
-}: {
-	type: "header" | "data";
-	faker: Faker;
-}) => ({
+const mockTableCell = ({ type, faker }: { type: "header" | "data"; faker: Faker }) => ({
 	type,
 	content: richText({
 		faker,
 		model: TableCell,
 	}),
-});
+})

package/src/value/timestamp.ts

@@ -1,58 +1,50 @@
-import * as prismic from "@prismicio/client";
+import type * as prismic from "@prismicio/client"
 
-import { createFaker } from "../lib/createFaker";
-
-import { MockValueStateConfig, MockValueConfig } from "../types";
+import { createFaker } from "../lib/createFaker"
+import type { MockValueStateConfig, MockValueConfig } from "../types"
 
 export type MockTimestampValueConfig<
-	Model extends
-		prismic.CustomTypeModelTimestampField = prismic.CustomTypeModelTimestampField,
+	Model extends prismic.CustomTypeModelTimestampField = prismic.CustomTypeModelTimestampField,
 	State extends prismic.FieldState = prismic.FieldState,
 > = {
-	after?: Date;
-	before?: Date;
+	after?: Date
+	before?: Date
 } & MockValueConfig<Model> &
-	MockValueStateConfig<State>;
+	MockValueStateConfig<State>
 
-export type MockTimestampValue<
-	State extends prismic.FieldState = prismic.FieldState,
-> = prismic.TimestampField<State>;
+export type MockTimestampValue<State extends prismic.FieldState = prismic.FieldState> =
+	prismic.TimestampField<State>
 
 export const timestamp = <
-	Model extends
-		prismic.CustomTypeModelTimestampField = prismic.CustomTypeModelTimestampField,
+	Model extends prismic.CustomTypeModelTimestampField = prismic.CustomTypeModelTimestampField,
 	State extends prismic.FieldState = "filled",
 >(
 	config: MockTimestampValueConfig<Model, State>,
 ): MockTimestampValue<State> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
 	if (config.state === "empty") {
-		return null as MockTimestampValue<State>;
+		return null as MockTimestampValue<State>
 	} else {
-		let date: Date;
+		let date: Date
 
 		// Working with Date objects produces non-deterministic values;
 		// machines can return different values due to differing
 		// timezones and other unknown factors. To get around this, we
 		// can can remove time from the given values and only use their dates.
-		const after = config.after
-			? new Date(config.after.toISOString().split("T")[0])
-			: undefined;
-		const before = config.before
-			? new Date(config.before.toISOString().split("T")[0])
-			: undefined;
+		const after = config.after ? new Date(config.after.toISOString().split("T")[0]) : undefined
+		const before = config.before ? new Date(config.before.toISOString().split("T")[0]) : undefined
 
 		if (after && before) {
-			date = faker.dateBetween(after, before);
+			date = faker.dateBetween(after, before)
 		} else if (after) {
-			date = faker.dateAfter(after);
+			date = faker.dateAfter(after)
 		} else if (before) {
-			date = faker.dateBefore(before);
+			date = faker.dateBefore(before)
 		} else {
-			date = faker.date();
+			date = faker.date()
 		}
 
-		return date.toISOString() as MockTimestampValue<State>;
+		return date.toISOString() as MockTimestampValue<State>
 	}
-};
+}

package/src/value/title.ts

@@ -1,35 +1,30 @@
-import * as prismic from "@prismicio/client";
+import type * as prismic from "@prismicio/client"
 
-import { createFaker } from "../lib/createFaker";
-
-import { MockValueConfig, MockValueStateConfig } from "../types";
-
-import { heading, MockRichTextHeadingValueConfig } from "./richText/heading";
+import { createFaker } from "../lib/createFaker"
+import type { MockValueConfig, MockValueStateConfig } from "../types"
+import { heading, type MockRichTextHeadingValueConfig } from "./richText/heading"
 
 export type MockTitleValueConfig<
-	Model extends
-		prismic.CustomTypeModelTitleField = prismic.CustomTypeModelTitleField,
+	Model extends prismic.CustomTypeModelTitleField = prismic.CustomTypeModelTitleField,
 	State extends prismic.FieldState = prismic.FieldState,
 > = {
-	pattern?: MockRichTextHeadingValueConfig["pattern"];
+	pattern?: MockRichTextHeadingValueConfig["pattern"]
 } & MockValueConfig<Model> &
-	MockValueStateConfig<State>;
+	MockValueStateConfig<State>
 
-export type MockTitleValue<
-	State extends prismic.FieldState = prismic.FieldState,
-> = prismic.TitleField<State>;
+export type MockTitleValue<State extends prismic.FieldState = prismic.FieldState> =
+	prismic.TitleField<State>
 
 export const title = <
-	Model extends
-		prismic.CustomTypeModelTitleField = prismic.CustomTypeModelTitleField,
+	Model extends prismic.CustomTypeModelTitleField = prismic.CustomTypeModelTitleField,
 	State extends prismic.FieldState = "filled",
 >(
 	config: MockTitleValueConfig<Model, State>,
 ): MockTitleValue<State> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
 	if (config.state === "empty") {
-		return [] as MockTitleValue<State>;
+		return [] as MockTitleValue<State>
 	} else {
 		return [
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -38,6 +33,6 @@ export const title = <
 				model: config.model,
 				pattern: config.pattern,
 			})!,
-		] as MockTitleValue<State>;
+		] as MockTitleValue<State>
 	}
-};
+}

package/src/value/uid.ts

@@ -1,22 +1,19 @@
-import * as prismic from "@prismicio/client";
+import type * as prismic from "@prismicio/client"
 
-import { snakeCase } from "../lib/changeCase";
-import { createFaker } from "../lib/createFaker";
-
-import { MockValueConfig } from "../types";
+import { snakeCase } from "../lib/changeCase"
+import { createFaker } from "../lib/createFaker"
+import type { MockValueConfig } from "../types"
 
 export type MockUIDValueConfig<
-	Model extends
-		prismic.CustomTypeModelUIDField = prismic.CustomTypeModelUIDField,
-> = MockValueConfig<Model>;
+	Model extends prismic.CustomTypeModelUIDField = prismic.CustomTypeModelUIDField,
+> = MockValueConfig<Model>
 
 export const uid = <
-	Model extends
-		prismic.CustomTypeModelUIDField = prismic.CustomTypeModelUIDField,
+	Model extends prismic.CustomTypeModelUIDField = prismic.CustomTypeModelUIDField,
 >(
 	config: MockUIDValueConfig<Model>,
 ): NonNullable<prismic.PrismicDocument["uid"]> => {
-	const faker = config.faker || createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed)
 
-	return snakeCase(faker.words(faker.range(1, 3)));
-};
+	return snakeCase(faker.words(faker.range(1, 3)))
+}

package/dist/constants.d.ts

@@ -1,2 +0,0 @@
-import { Seed } from "./types";
-export declare const FAKER_SEED: Seed;

package/dist/index.cjs.map

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

package/dist/index.js.map

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

package/dist/lib/PRNG.d.ts

@@ -1,48 +0,0 @@
-/**
- * The following code is a modified version of Prando from `zeh/prando` on
- * GitHub.
- *
- * Source:
- * https://github.com/zeh/prando/blob/acc2a3c09df12a41b5c82fbf44e49e070e6f60ac/src/Prando.ts
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2016 Zeh Fernando
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-/**
- * Pseudorandom number generator.
- */
-export declare class PRNG {
-    private _value;
-    /**
-     * Generate a new pseudo-random number generator.
-     *
-     * @param seed - A number or string seed that determines which pseudo-random
-     *   number sequence will be created.
-     */
-    constructor(seed: number | string);
-    /**
-     * Generates a pseudo-random number.
-     *
-     * @returns The generated pseudo-random number.
-     */
-    next(): number;
-}

package/dist/lib/buildAlternativeLanguage.d.ts

@@ -1,6 +0,0 @@
-import * as prismic from "@prismicio/client";
-type BuildEmbedFieldConfig<Document extends prismic.PrismicDocument> = {
-    document: Document;
-};
-export declare const buildAlternativeLanguage: <Document extends prismic.PrismicDocument<Record<string, any>, string, string>>(config: BuildEmbedFieldConfig<Document>) => prismic.AlternateLanguage<Document["type"], Document["lang"]>;
-export {};

package/dist/lib/buildContentRelationshipField.d.ts

@@ -1,6 +0,0 @@
-import * as prismic from "@prismicio/client";
-type BuildContentRelationshipFieldConfig<Document extends prismic.PrismicDocument> = {
-    document: Document;
-};
-export declare const buildContentRelationshipField: <Document extends prismic.PrismicDocument<Record<string, any>, string, string>>(config: BuildContentRelationshipFieldConfig<Document>) => prismic.ContentRelationshipField<Document["type"], Document["lang"], never, "filled">;
-export {};

package/dist/lib/buildEmbedField.d.ts

@@ -1,16 +0,0 @@
-import * as prismic from "@prismicio/client";
-import { Faker } from "../lib/createFaker";
-import { Seed } from "../types";
-type BuildEmbedFieldConfig<Data extends prismic.AnyOEmbed = prismic.AnyOEmbed> = {
-    url?: string;
-    html?: string;
-    data: Data;
-} & ({
-    seed: Seed;
-    faker?: never;
-} | {
-    faker: Faker;
-    seed?: never;
-});
-export declare const buildEmbedField: <Data extends prismic.AnyOEmbed = prismic.AnyOEmbed>(config: BuildEmbedFieldConfig<Data>) => prismic.EmbedField<Data, "filled">;
-export {};