@prismicio/mock 0.0.3 → 0.0.7

package/dist/index.d.ts

@@ -19,99 +19,80 @@ declare type ValueForModelMapConfigs = {
     number?: MockNumberValueConfig;
     richText?: MockRichTextValueConfig$1;
     select?: MockSelectValueConfig;
-    slices?: MockSliceZoneValueConfig;
+    sliceZone?: MockSliceZoneValueConfig;
     timestamp?: MockTimestampValueConfig;
     title?: MockTitleValueConfig;
     uid?: MockUIDValueConfig;
 };
 
 declare type MockCustomTypeValueConfig<Model extends prismicT.CustomTypeModel = prismicT.CustomTypeModel> = {
-    sharedSliceModels?: prismicT.SharedSliceModel[];
+    withURL?: boolean;
+    alternateLanguages?: prismicT.PrismicDocument[];
     configs?: ValueForModelMapConfigs;
 } & MockValueConfig<Model>;
 declare const customType$1: <Model extends prismicT.CustomTypeModel<string, prismicT.CustomTypeModelDefinition<string>> = prismicT.CustomTypeModel<string, prismicT.CustomTypeModelDefinition<string>>>(config?: MockCustomTypeValueConfig<Model>) => ModelValue<Model>;
 
-declare type MockColorValueConfig<Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField> = MockValueConfig<Model>;
-declare const color$1: (config?: MockColorValueConfig) => prismicT.ColorField;
+declare type MockColorValueConfig<Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const color$1: <Model extends prismicT.CustomTypeModelColorField = prismicT.CustomTypeModelColorField, State extends prismicT.FieldState = "filled">(config?: MockColorValueConfig<Model, State>) => prismicT.ColorField<State>;
 
-declare type MockContentRelationshipValueConfig<IsFilled extends boolean = boolean, Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField> = {
-    isFilled?: IsFilled;
+declare type MockContentRelationshipValueConfig<Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField, State extends prismicT.FieldState = prismicT.FieldState> = {
     /**
      * A list of potential documents to which the field can be linked.
      */
     linkableDocuments?: prismicT.PrismicDocument[];
-} & MockValueConfig<Model>;
-declare type MockContentRelationshipValue<IsFilled extends boolean = boolean> = IsFilled extends true ? prismicT.FilledLinkToDocumentField : prismicT.EmptyLinkField<prismicT.LinkType.Document>;
-declare const contentRelationship$1: <IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelContentRelationshipField = prismicT.CustomTypeModelContentRelationshipField>(config?: MockContentRelationshipValueConfig<IsFilled, Model>) => MockContentRelationshipValue<IsFilled>;
+} & MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const contentRelationship$1: <Model extends prismicT.CustomTypeModelContentRelationshipField<string, string> = prismicT.CustomTypeModelContentRelationshipField<string, string>, State extends prismicT.FieldState = "filled">(config?: MockContentRelationshipValueConfig<Model, State>) => prismicT.RelationField<Model["config"]["customtypes"], string, never, State>;
 
-declare type MockTimestampValueConfig<Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField> = {
+declare type MockTimestampValueConfig<Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField, State extends prismicT.FieldState = prismicT.FieldState> = {
     after?: Date;
     before?: Date;
-} & MockValueConfig<Model>;
-declare const timestamp$1: (config?: MockTimestampValueConfig) => prismicT.TimestampField;
+} & MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const timestamp$1: <Model extends prismicT.CustomTypeModelTimestampField = prismicT.CustomTypeModelTimestampField, State extends prismicT.FieldState = "filled">(config?: MockTimestampValueConfig<Model, State>) => prismicT.TimestampField<State>;
 
-declare type MockDateValueConfig<Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField> = Pick<MockTimestampValueConfig, "after" | "before"> & MockValueConfig<Model>;
-declare const date$1: (config?: MockDateValueConfig) => prismicT.DateField;
+declare type MockDateValueConfig<Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField, State extends prismicT.FieldState = prismicT.FieldState> = Pick<MockTimestampValueConfig, "after" | "before"> & MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const date$1: <Model extends prismicT.CustomTypeModelDateField = prismicT.CustomTypeModelDateField, State extends prismicT.FieldState = "filled">(config?: MockDateValueConfig<Model, State>) => prismicT.DateField<State>;
 
-declare type MockEmbedValueConfig<Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField> = MockValueConfig<Model>;
-declare const embed$1: (config?: MockEmbedValueConfig) => prismicT.EmbedField;
+declare type MockEmbedValueConfig<Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const embed$1: <Model extends prismicT.CustomTypeModelEmbedField = prismicT.CustomTypeModelEmbedField, State extends prismicT.FieldState = "filled">(config?: MockEmbedValueConfig<Model, State>) => prismicT.EmbedField<prismicT.AnyOEmbed & prismicT.OEmbedExtra, State>;
 
-declare type MockGeoPointValueConfig<Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField> = MockValueConfig<Model>;
-declare const geoPoint$1: (config?: MockGeoPointValueConfig) => prismicT.GeoPointField;
+declare type MockGeoPointValueConfig<Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const geoPoint$1: <Model extends prismicT.CustomTypeModelGeoPointField = prismicT.CustomTypeModelGeoPointField, State extends prismicT.FieldState = "filled">(config?: MockGeoPointValueConfig<Model, State>) => prismicT.GeoPointField<State>;
 
-declare const patterns$5: {
-    readonly short: {
-        readonly minItems: 1;
-        readonly maxItems: 3;
-    };
-    readonly medium: {
-        readonly minItems: 3;
-        readonly maxItems: 6;
-    };
-    readonly long: {
-        readonly minItems: 6;
-        readonly maxItems: 12;
-    };
-};
 declare type MockGroupValueConfig<Model extends prismicT.CustomTypeModelGroupField = prismicT.CustomTypeModelGroupField> = {
-    pattern?: keyof typeof patterns$5;
+    itemsCount?: number;
     configs?: ValueForModelMapConfigs;
 } & MockValueConfig<Model>;
 declare const group$1: <Model extends prismicT.CustomTypeModelGroupField<Record<string, prismicT.CustomTypeModelFieldForGroup>> = prismicT.CustomTypeModelGroupField<Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockGroupValueConfig<Model>) => ModelValue<Model>;
 
-declare type MockImageValueConfig<Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField> = MockValueConfig<Model>;
-declare const image$1: (config?: MockImageValueConfig) => prismicT.ImageField;
+declare type MockImageValueConfig<Model extends prismicT.CustomTypeModelImageField = prismicT.CustomTypeModelImageField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const image$1: <Model extends prismicT.CustomTypeModelImageField<string> = prismicT.CustomTypeModelImageField<string>, State extends prismicT.FieldState = "filled">(config?: MockImageValueConfig<Model, State>) => prismicT.ImageField<Model["config"]["thumbnails"][number]["name"], State>;
 
-declare type MockIntegrationFieldsValueConfig<Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob extends unknown = unknown> = {
+declare type MockIntegrationFieldsValueConfig<Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob = unknown, State extends prismicT.FieldState = prismicT.FieldState> = {
     data?: Blob;
-} & MockValueConfig<Model>;
-declare const integrationFields$1: <Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob_1 extends unknown = unknown>(config?: MockIntegrationFieldsValueConfig<Model, Blob_1>) => prismicT.IntegrationFields<Blob_1>;
+} & MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const integrationFields$1: <Model extends prismicT.CustomTypeModelIntegrationFieldsField = prismicT.CustomTypeModelIntegrationFieldsField, Blob_1 = unknown, State extends prismicT.FieldState = "filled">(config?: MockIntegrationFieldsValueConfig<Model, Blob_1, State>) => prismicT.IntegrationFields<Blob_1, State>;
 
-declare type MockKeyTextValueConfig<Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField> = MockValueConfig<Model>;
-declare const keyText$1: (config?: MockKeyTextValueConfig) => prismicT.KeyTextField;
+declare type MockKeyTextValueConfig<Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const keyText$1: <Model extends prismicT.CustomTypeModelKeyTextField = prismicT.CustomTypeModelKeyTextField, State extends prismicT.FieldState = "filled">(config?: MockKeyTextValueConfig<Model, State>) => prismicT.KeyTextField<State>;
 
-declare type MockLinkValueConfig<LinkType extends prismicT.LinkType = prismicT.LinkType, IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField> = {
+declare type MockLinkValueConfig<LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType], Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField, State extends prismicT.FieldState = prismicT.FieldState> = {
     type?: LinkType;
-    isFilled?: IsFilled;
     withTargetBlank?: Model["config"]["allowTargetBlank"] extends undefined ? false : boolean;
     /**
      * A list of potential documents to which the field can be linked.
      */
-    linkableDocuments?: LinkType extends prismicT.LinkType.Document ? prismicT.PrismicDocument[] : never;
-} & MockValueConfig<Model>;
-declare type MockLinkValue<LinkType extends prismicT.LinkType = prismicT.LinkType, IsFilled extends boolean = true> = IsFilled extends true ? LinkType extends prismicT.LinkType.Web ? prismicT.FilledLinkToWebField : LinkType extends prismicT.LinkType.Media ? prismicT.FilledLinkToMediaField : LinkType extends prismicT.LinkType.Document ? prismicT.FilledLinkToDocumentField : never : prismicT.EmptyLinkField<LinkType>;
-declare const link$1: <LinkType extends prismicT.LinkType = prismicT.LinkType, IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField>(config?: MockLinkValueConfig<LinkType, IsFilled, Model>) => MockLinkValue<LinkType, IsFilled>;
+    linkableDocuments?: LinkType extends typeof prismicT.LinkType.Document ? prismicT.PrismicDocument[] : never;
+} & MockValueConfig<Model> & MockValueStateConfig<State>;
+declare type MockLinkValue<LinkType extends typeof prismicT.LinkType[keyof typeof prismicT.LinkType] = typeof prismicT.LinkType[keyof typeof prismicT.LinkType], State extends prismicT.FieldState = "filled"> = State extends "empty" ? prismicT.EmptyLinkField<LinkType> : LinkType extends typeof prismicT.LinkType.Web ? prismicT.FilledLinkToWebField : LinkType extends typeof prismicT.LinkType.Media ? prismicT.FilledLinkToMediaField : LinkType extends typeof prismicT.LinkType.Document ? prismicT.FilledLinkToDocumentField : never;
+declare const link$1: <LinkType extends "Any" | "Document" | "Media" | "Web" = "Any" | "Document" | "Media" | "Web", Model extends prismicT.CustomTypeModelLinkField = prismicT.CustomTypeModelLinkField, State extends prismicT.FieldState = "filled">(config?: MockLinkValueConfig<LinkType, Model, State>) => MockLinkValue<LinkType, State>;
 
-declare type MockLinkToMediaValueConfig<IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField> = {
-    isFilled?: IsFilled;
-} & MockValueConfig<Model>;
-declare type MockLinkToMediaValue<IsFilled extends boolean = true> = IsFilled extends true ? prismicT.FilledLinkToMediaField : prismicT.EmptyLinkField<prismicT.LinkType.Media>;
-declare const linkToMedia$1: <IsFilled extends boolean = true, Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField>(config?: MockLinkToMediaValueConfig<IsFilled, Model>) => MockLinkToMediaValue<IsFilled>;
+declare type MockLinkToMediaValueConfig<Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const linkToMedia$1: <Model extends prismicT.CustomTypeModelLinkToMediaField = prismicT.CustomTypeModelLinkToMediaField, State extends prismicT.FieldState = "filled">(config?: MockLinkToMediaValueConfig<Model, State>) => prismicT.LinkToMediaField<State>;
 
-declare type MockNumberValueConfig<Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField> = MockValueConfig<Model>;
-declare const number$1: (config?: MockNumberValueConfig) => prismicT.NumberField;
+declare type MockNumberValueConfig<Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const number$1: <Model extends prismicT.CustomTypeModelNumberField = prismicT.CustomTypeModelNumberField, State extends prismicT.FieldState = "filled">(config?: MockNumberValueConfig<Model, State>) => prismicT.NumberField<State>;
 
-declare const patterns$4: {
+declare const patterns$1: {
     readonly short: {
         readonly blockCountMin: 1;
         readonly blockCountMax: 2;
@@ -126,91 +107,41 @@ declare const patterns$4: {
     };
 };
 declare type MockRichTextValueConfig$1 = {
-    pattern?: keyof typeof patterns$4;
+    pattern?: keyof typeof patterns$1;
 } & MockRichTextValueConfig<prismicT.CustomTypeModelRichTextField>;
 declare const richText$1: (config?: MockRichTextValueConfig$1) => prismicT.RichTextField;
 
-declare type MockSelectValueConfig<Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField> = MockValueConfig<Model>;
-declare const select$1: (config?: MockSelectValueConfig) => prismicT.SelectField;
+declare type MockSelectValueConfig<Model extends prismicT.CustomTypeModelSelectField = prismicT.CustomTypeModelSelectField, State extends prismicT.FieldState = prismicT.FieldState> = MockValueConfig<Model> & MockValueStateConfig<State>;
+declare const select$1: <Model extends prismicT.CustomTypeModelSelectField<string, string> = prismicT.CustomTypeModelSelectField<string, string>, State extends prismicT.FieldState = "filled">(config?: MockSelectValueConfig<Model, State>) => prismicT.SelectField<Model["config"]["options"][number], State>;
 
-declare const patterns$3: {
-    readonly none: {
-        readonly minItems: 0;
-        readonly maxItems: 0;
-    };
-    readonly short: {
-        readonly minItems: 1;
-        readonly maxItems: 3;
-    };
-    readonly medium: {
-        readonly minItems: 3;
-        readonly maxItems: 6;
-    };
-    readonly long: {
-        readonly minItems: 6;
-        readonly maxItems: 12;
-    };
-};
 declare type MockSliceValueConfig<Model extends prismicT.CustomTypeModelSlice = prismicT.CustomTypeModelSlice> = {
     type?: string;
     label?: string | null;
-    pattern?: keyof typeof patterns$3;
+    itemsCount?: number;
     primaryFieldConfigs?: ValueForModelMapConfigs;
     itemsFieldConfigs?: ValueForModelMapConfigs;
 } & MockValueConfig<Model>;
 declare const slice$1: <Model extends prismicT.CustomTypeModelSlice<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> = prismicT.CustomTypeModelSlice<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSliceValueConfig<Model>) => ModelValue<Model>;
 
-declare const patterns$2: {
-    readonly short: {
-        readonly minItems: 1;
-        readonly maxItems: 3;
-    };
-    readonly medium: {
-        readonly minItems: 3;
-        readonly maxItems: 6;
-    };
-    readonly long: {
-        readonly minItems: 6;
-        readonly maxItems: 12;
-    };
-};
 declare type MockSliceZoneValueConfig<Model extends prismicT.CustomTypeModelSliceZoneField = prismicT.CustomTypeModelSliceZoneField> = {
     sharedSliceModels?: prismicT.SharedSliceModel[];
-    pattern?: keyof typeof patterns$2;
+    itemsCount?: number;
     primaryFieldConfigs?: ValueForModelMapConfigs;
     itemsFieldConfigs?: ValueForModelMapConfigs;
 } & MockValueConfig<Model>;
 declare const sliceZone$1: <Model extends prismicT.CustomTypeModelSliceZoneField<Record<string, prismicT.CustomTypeModelSlice<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> | prismicT.CustomTypeModelSharedSlice>> = prismicT.CustomTypeModelSliceZoneField<Record<string, prismicT.CustomTypeModelSlice<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> | prismicT.CustomTypeModelSharedSlice>>>(config?: MockSliceZoneValueConfig<Model>) => ModelValue<Model>;
 
-declare const patterns$1: {
-    readonly none: {
-        readonly minItems: 0;
-        readonly maxItems: 0;
-    };
-    readonly short: {
-        readonly minItems: 1;
-        readonly maxItems: 3;
-    };
-    readonly medium: {
-        readonly minItems: 3;
-        readonly maxItems: 6;
-    };
-    readonly long: {
-        readonly minItems: 6;
-        readonly maxItems: 12;
-    };
-};
 declare type MockSharedSliceVariationValueConfig<Model extends prismicT.SharedSliceModelVariation = prismicT.SharedSliceModelVariation> = {
     type?: string;
     label?: string;
-    pattern?: keyof typeof patterns$1;
+    itemsCount?: number;
     primaryFieldConfigs?: ValueForModelMapConfigs;
     itemsFieldConfigs?: ValueForModelMapConfigs;
 } & MockValueConfig<Model>;
-declare const sharedSliceVariation$1: <Model extends prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> = prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceVariationValueConfig<Model>) => ModelValue<Model>;
+declare const sharedSliceVariation$1: <Model extends prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>> = prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>(config?: MockSharedSliceVariationValueConfig<Model>) => ModelValue<Model>;
 
-declare type MockSharedSliceValueConfig<Model extends prismicT.SharedSliceModel = prismicT.SharedSliceModel> = Pick<MockSharedSliceVariationValueConfig, "pattern" | "primaryFieldConfigs" | "itemsFieldConfigs"> & MockValueConfig<Model>;
-declare const sharedSlice$1: <Model extends prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>> = prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>>(config?: MockSharedSliceValueConfig<Model>) => ModelValue<Model>;
+declare type MockSharedSliceValueConfig<Model extends prismicT.SharedSliceModel = prismicT.SharedSliceModel> = Pick<MockSharedSliceVariationValueConfig, "itemsCount" | "primaryFieldConfigs" | "itemsFieldConfigs"> & MockValueConfig<Model>;
+declare const sharedSlice$1: <Model extends prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>> = prismicT.SharedSliceModel<string, prismicT.SharedSliceModelVariation<string, Record<string, prismicT.CustomTypeModelFieldForGroup>, Record<string, prismicT.CustomTypeModelFieldForGroup>>>>(config?: MockSharedSliceValueConfig<Model>) => ModelValue<Model>;
 
 declare const patterns: {
     readonly short: {
@@ -236,189 +167,197 @@ declare type MockTitleValueConfig<Model extends prismicT.CustomTypeModelTitleFie
 declare const title$1: (config?: MockTitleValueConfig) => prismicT.TitleField;
 
 declare type MockUIDValueConfig<Model extends prismicT.CustomTypeModelUIDField = prismicT.CustomTypeModelUIDField> = MockValueConfig<Model>;
-declare const uid$1: (config?: MockUIDValueConfig) => prismicT.PrismicDocument["uid"];
-
-type index$1_MockBooleanValueConfig<_0> = MockBooleanValueConfig<_0>;
-type index$1_MockCustomTypeValueConfig<_0> = MockCustomTypeValueConfig<_0>;
-type index$1_MockColorValueConfig<_0> = MockColorValueConfig<_0>;
-type index$1_MockContentRelationshipValueConfig<_0, _1> = MockContentRelationshipValueConfig<_0, _1>;
-type index$1_MockDateValueConfig<_0> = MockDateValueConfig<_0>;
-type index$1_MockEmbedValueConfig<_0> = MockEmbedValueConfig<_0>;
-type index$1_MockGeoPointValueConfig<_0> = MockGeoPointValueConfig<_0>;
-type index$1_MockGroupValueConfig<_0> = MockGroupValueConfig<_0>;
-type index$1_MockImageValueConfig<_0> = MockImageValueConfig<_0>;
-type index$1_MockIntegrationFieldsValueConfig<_0, _1> = MockIntegrationFieldsValueConfig<_0, _1>;
-type index$1_MockKeyTextValueConfig<_0> = MockKeyTextValueConfig<_0>;
-type index$1_MockLinkValueConfig<_0, _1, _2> = MockLinkValueConfig<_0, _1, _2>;
-type index$1_MockLinkToMediaValueConfig<_0, _1> = MockLinkToMediaValueConfig<_0, _1>;
-type index$1_MockNumberValueConfig<_0> = MockNumberValueConfig<_0>;
-type index$1_MockSelectValueConfig<_0> = MockSelectValueConfig<_0>;
-type index$1_MockSliceValueConfig<_0> = MockSliceValueConfig<_0>;
-type index$1_MockSliceZoneValueConfig<_0> = MockSliceZoneValueConfig<_0>;
-type index$1_MockSharedSliceValueConfig<_0> = MockSharedSliceValueConfig<_0>;
-type index$1_MockSharedSliceVariationValueConfig<_0> = MockSharedSliceVariationValueConfig<_0>;
-type index$1_MockTimestampValueConfig<_0> = MockTimestampValueConfig<_0>;
-type index$1_MockTitleValueConfig<_0> = MockTitleValueConfig<_0>;
-type index$1_MockUIDValueConfig<_0> = MockUIDValueConfig<_0>;
-declare namespace index$1 {
+declare const uid$1: (config?: MockUIDValueConfig) => NonNullable<prismicT.PrismicDocument["uid"]>;
+
+type index$2_MockBooleanValueConfig<_0> = MockBooleanValueConfig<_0>;
+type index$2_MockCustomTypeValueConfig<_0> = MockCustomTypeValueConfig<_0>;
+type index$2_MockColorValueConfig<_0, _1> = MockColorValueConfig<_0, _1>;
+type index$2_MockContentRelationshipValueConfig<_0, _1> = MockContentRelationshipValueConfig<_0, _1>;
+type index$2_MockDateValueConfig<_0, _1> = MockDateValueConfig<_0, _1>;
+type index$2_MockEmbedValueConfig<_0, _1> = MockEmbedValueConfig<_0, _1>;
+type index$2_MockGeoPointValueConfig<_0, _1> = MockGeoPointValueConfig<_0, _1>;
+type index$2_MockGroupValueConfig<_0> = MockGroupValueConfig<_0>;
+type index$2_MockImageValueConfig<_0, _1> = MockImageValueConfig<_0, _1>;
+type index$2_MockIntegrationFieldsValueConfig<_0, _1, _2> = MockIntegrationFieldsValueConfig<_0, _1, _2>;
+type index$2_MockKeyTextValueConfig<_0, _1> = MockKeyTextValueConfig<_0, _1>;
+type index$2_MockLinkValueConfig<_0, _1, _2> = MockLinkValueConfig<_0, _1, _2>;
+type index$2_MockLinkToMediaValueConfig<_0, _1> = MockLinkToMediaValueConfig<_0, _1>;
+type index$2_MockNumberValueConfig<_0, _1> = MockNumberValueConfig<_0, _1>;
+type index$2_MockSelectValueConfig<_0, _1> = MockSelectValueConfig<_0, _1>;
+type index$2_MockSliceValueConfig<_0> = MockSliceValueConfig<_0>;
+type index$2_MockSliceZoneValueConfig<_0> = MockSliceZoneValueConfig<_0>;
+type index$2_MockSharedSliceValueConfig<_0> = MockSharedSliceValueConfig<_0>;
+type index$2_MockSharedSliceVariationValueConfig<_0> = MockSharedSliceVariationValueConfig<_0>;
+type index$2_MockTimestampValueConfig<_0, _1> = MockTimestampValueConfig<_0, _1>;
+type index$2_MockTitleValueConfig<_0> = MockTitleValueConfig<_0>;
+type index$2_MockUIDValueConfig<_0> = MockUIDValueConfig<_0>;
+declare namespace index$2 {
   export {
     boolean$1 as boolean,
-    index$1_MockBooleanValueConfig as MockBooleanValueConfig,
+    index$2_MockBooleanValueConfig as MockBooleanValueConfig,
     customType$1 as customType,
-    index$1_MockCustomTypeValueConfig as MockCustomTypeValueConfig,
+    index$2_MockCustomTypeValueConfig as MockCustomTypeValueConfig,
     color$1 as color,
-    index$1_MockColorValueConfig as MockColorValueConfig,
+    index$2_MockColorValueConfig as MockColorValueConfig,
     contentRelationship$1 as contentRelationship,
-    index$1_MockContentRelationshipValueConfig as MockContentRelationshipValueConfig,
+    index$2_MockContentRelationshipValueConfig as MockContentRelationshipValueConfig,
     customType$1 as document,
     MockCustomTypeValueConfig as MockDocumentValueConfig,
     date$1 as date,
-    index$1_MockDateValueConfig as MockDateValueConfig,
+    index$2_MockDateValueConfig as MockDateValueConfig,
     embed$1 as embed,
-    index$1_MockEmbedValueConfig as MockEmbedValueConfig,
+    index$2_MockEmbedValueConfig as MockEmbedValueConfig,
     geoPoint$1 as geoPoint,
-    index$1_MockGeoPointValueConfig as MockGeoPointValueConfig,
+    index$2_MockGeoPointValueConfig as MockGeoPointValueConfig,
     group$1 as group,
-    index$1_MockGroupValueConfig as MockGroupValueConfig,
+    index$2_MockGroupValueConfig as MockGroupValueConfig,
     image$1 as image,
-    index$1_MockImageValueConfig as MockImageValueConfig,
+    index$2_MockImageValueConfig as MockImageValueConfig,
     integrationFields$1 as integrationFields,
-    index$1_MockIntegrationFieldsValueConfig as MockIntegrationFieldsValueConfig,
+    index$2_MockIntegrationFieldsValueConfig as MockIntegrationFieldsValueConfig,
     keyText$1 as keyText,
-    index$1_MockKeyTextValueConfig as MockKeyTextValueConfig,
+    index$2_MockKeyTextValueConfig as MockKeyTextValueConfig,
     link$1 as link,
-    index$1_MockLinkValueConfig as MockLinkValueConfig,
+    index$2_MockLinkValueConfig as MockLinkValueConfig,
     linkToMedia$1 as linkToMedia,
-    index$1_MockLinkToMediaValueConfig as MockLinkToMediaValueConfig,
+    index$2_MockLinkToMediaValueConfig as MockLinkToMediaValueConfig,
     number$1 as number,
-    index$1_MockNumberValueConfig as MockNumberValueConfig,
+    index$2_MockNumberValueConfig as MockNumberValueConfig,
     richText$1 as richText,
     MockRichTextValueConfig$1 as MockRichTextValueConfig,
     select$1 as select,
-    index$1_MockSelectValueConfig as MockSelectValueConfig,
+    index$2_MockSelectValueConfig as MockSelectValueConfig,
     slice$1 as slice,
-    index$1_MockSliceValueConfig as MockSliceValueConfig,
+    index$2_MockSliceValueConfig as MockSliceValueConfig,
     sliceZone$1 as sliceZone,
-    index$1_MockSliceZoneValueConfig as MockSliceZoneValueConfig,
+    index$2_MockSliceZoneValueConfig as MockSliceZoneValueConfig,
     sharedSlice$1 as sharedSlice,
-    index$1_MockSharedSliceValueConfig as MockSharedSliceValueConfig,
+    index$2_MockSharedSliceValueConfig as MockSharedSliceValueConfig,
     sharedSliceVariation$1 as sharedSliceVariation,
-    index$1_MockSharedSliceVariationValueConfig as MockSharedSliceVariationValueConfig,
+    index$2_MockSharedSliceVariationValueConfig as MockSharedSliceVariationValueConfig,
     timestamp$1 as timestamp,
-    index$1_MockTimestampValueConfig as MockTimestampValueConfig,
+    index$2_MockTimestampValueConfig as MockTimestampValueConfig,
     title$1 as title,
-    index$1_MockTitleValueConfig as MockTitleValueConfig,
+    index$2_MockTitleValueConfig as MockTitleValueConfig,
     uid$1 as uid,
-    index$1_MockUIDValueConfig as MockUIDValueConfig,
+    index$2_MockUIDValueConfig as MockUIDValueConfig,
   };
 }
 
 declare type IterableElement<TargetIterable> = TargetIterable extends Iterable<infer ElementType> ? ElementType : TargetIterable extends AsyncIterable<infer ElementType> ? ElementType : never;
-declare type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
+declare type ValueOf<ObjectType extends Record<string, unknown>> = ObjectType[string];
+declare type Seed = string | number | number[];
+declare type MockRestApiConfig = {
+    seed?: Seed;
+};
 declare type MockModelConfig = {
-    seed?: number;
+    seed?: Seed;
 };
 declare type PrismicModel = prismicT.CustomTypeModel | prismicT.CustomTypeModelField | prismicT.CustomTypeModelSlice | prismicT.SharedSliceModel | prismicT.SharedSliceModelVariation;
+declare type GroupFieldModelMap = Record<string, prismicT.CustomTypeModelFieldForGroup>;
 declare type MockValueConfig<Model extends PrismicModel = PrismicModel> = {
-    seed?: number;
+    seed?: Seed;
     model?: Model;
 };
+declare type MockValueStateConfig<State extends prismicT.FieldState = prismicT.FieldState> = {
+    state?: State;
+};
 declare type CustomTypeModelStructuredTextField = prismicT.CustomTypeModelRichTextField | prismicT.CustomTypeModelTitleField;
 declare type MockRichTextValueConfig<Model extends CustomTypeModelStructuredTextField = CustomTypeModelStructuredTextField> = {
-    seed?: number;
+    seed?: Seed;
     model?: Model;
 };
 declare type ModelValueMap<T extends Record<string, prismicT.CustomTypeModelField>> = {
     [P in keyof T]: ModelValue<T[P]>;
 };
-declare type ModelValue<T extends PrismicModel> = T extends prismicT.CustomTypeModel ? CustomTypeModelValue<T> : T extends prismicT.CustomTypeModelUIDField ? prismicT.PrismicDocument["uid"] : T extends prismicT.CustomTypeModelFieldForGroup ? CustomTypeModelFieldForGroupValue<T> : T extends prismicT.CustomTypeModelGroupField ? CustomTypeModelGroupFieldValue<T> : T extends prismicT.CustomTypeModelSliceZoneField ? prismicT.SliceZone : T extends prismicT.CustomTypeModelSlice ? CustomTypeModelSliceValue<T> : T extends prismicT.CustomTypeModelSharedSlice ? prismicT.SharedSlice : T extends prismicT.SharedSliceModel ? SharedSliceModelValue<T> : T extends prismicT.SharedSliceModelVariation ? SharedSliceModelVariationValue<T> : never;
-declare type CustomTypeModelValue<T extends prismicT.CustomTypeModel> = prismicT.PrismicDocument<ModelValueMap<ValueOf<T["json"]>>>;
+declare type ModelValue<T extends PrismicModel> = T extends prismicT.CustomTypeModel ? CustomTypeModelValue<T> : T extends prismicT.CustomTypeModelUIDField ? prismicT.PrismicDocument["uid"] : T extends prismicT.CustomTypeModelFieldForGroup ? CustomTypeModelFieldForGroupValue<T> : T extends prismicT.CustomTypeModelGroupField ? CustomTypeModelGroupFieldValue<T> : T extends prismicT.CustomTypeModelSliceZoneField ? prismicT.SliceZone<ValueOf<{
+    [P in keyof T["config"]["choices"] as P extends string ? P : never]: T["config"]["choices"][P] extends prismicT.CustomTypeModelSlice ? CustomTypeModelSliceValue<T["config"]["choices"][P], P> : T["config"]["choices"][P] extends prismicT.CustomTypeModelSharedSlice ? prismicT.SharedSlice<P> : never;
+}>> : T extends prismicT.CustomTypeModelSlice ? CustomTypeModelSliceValue<T> : T extends prismicT.CustomTypeModelSharedSlice ? prismicT.SharedSlice : T extends prismicT.SharedSliceModel ? SharedSliceModelValue<T> : T extends prismicT.SharedSliceModelVariation ? SharedSliceModelVariationValue<T> : never;
+declare type CustomTypeModelValue<T extends prismicT.CustomTypeModel> = prismicT.PrismicDocument<ModelValueMap<{
+    [P in keyof ValueOf<T["json"]> as ValueOf<T["json"]>[P]["type"] extends typeof prismicT.CustomTypeModelFieldType.UID ? never : P]: ValueOf<T["json"]>[P];
+}>>;
 declare type CustomTypeModelFieldForGroupValue<T extends prismicT.CustomTypeModelFieldForGroup> = T extends prismicT.CustomTypeModelBooleanField ? prismicT.BooleanField : T extends prismicT.CustomTypeModelColorField ? prismicT.ColorField : T extends prismicT.CustomTypeModelTitleField ? prismicT.TitleField : T extends prismicT.CustomTypeModelRichTextField ? prismicT.RichTextField : T extends prismicT.CustomTypeModelImageField ? prismicT.ImageField : T extends prismicT.CustomTypeModelLinkField ? prismicT.LinkField : T extends prismicT.CustomTypeModelLinkToMediaField ? prismicT.LinkToMediaField : T extends prismicT.CustomTypeModelContentRelationshipField ? prismicT.RelationField : T extends prismicT.CustomTypeModelDateField ? prismicT.DateField : T extends prismicT.CustomTypeModelTimestampField ? prismicT.TimestampField : T extends prismicT.CustomTypeModelNumberField ? prismicT.NumberField : T extends prismicT.CustomTypeModelKeyTextField ? prismicT.KeyTextField : T extends prismicT.CustomTypeModelSelectField ? prismicT.SelectField : T extends prismicT.CustomTypeModelEmbedField ? prismicT.EmbedField : T extends prismicT.CustomTypeModelGeoPointField ? prismicT.GeoPointField : T extends prismicT.CustomTypeModelIntegrationFieldsField ? prismicT.IntegrationFields : never;
 declare type CustomTypeModelGroupFieldValue<T extends prismicT.CustomTypeModelGroupField> = prismicT.GroupField<ModelValueMap<T["config"]["fields"]>>;
-declare type CustomTypeModelSliceValue<T extends prismicT.CustomTypeModelSlice> = prismicT.Slice<string, ModelValueMap<T["non-repeat"]>, ModelValueMap<T["repeat"]>>;
+declare type CustomTypeModelSliceValue<T extends prismicT.CustomTypeModelSlice, SliceType = string> = prismicT.Slice<SliceType, ModelValueMap<T["non-repeat"]>, ModelValueMap<T["repeat"]>>;
 declare type SharedSliceModelValue<T extends prismicT.SharedSliceModel> = prismicT.SharedSlice<T["id"], SharedSliceModelVariationValue<IterableElement<T["variations"]>>>;
 declare type SharedSliceModelVariationValue<T extends prismicT.SharedSliceModelVariation> = prismicT.SharedSlice<string, prismicT.SharedSliceVariation<T["id"], ModelValueMap<T["primary"]>, ModelValueMap<T["items"]>>>;
 
+declare type MockRestApiRepositoryConfig = {
+    customTypeModels?: prismicT.CustomTypeModel[];
+    withReleases?: boolean;
+} & MockRestApiConfig;
+declare const repository: (config?: MockRestApiRepositoryConfig) => prismicT.Repository;
+
+declare type MockRestApiRefConfig<IsScheduled extends boolean = false> = {
+    isMasterRef?: boolean;
+    isScheduled?: IsScheduled;
+} & MockRestApiConfig;
+declare type MockRestApiRefValue<IsScheduled extends boolean = false> = Omit<prismicT.Ref, "scheduledAt"> & (IsScheduled extends true ? {
+    scheduledAt: string;
+} : {
+    scheduledAt?: never;
+});
+declare const ref: <IsScheduled extends boolean = false>(config?: MockRestApiRefConfig<IsScheduled>) => MockRestApiRefValue<IsScheduled>;
+
+declare type MockRestApiQueryConfig<Document extends prismicT.PrismicDocument = prismicT.PrismicDocument> = {
+    documents?: Document[];
+    page?: number;
+    pageSize?: number;
+} & MockRestApiConfig;
+declare const query: <Document_1 extends prismicT.PrismicDocument<Record<string, any>, string, string> = prismicT.PrismicDocument<Record<string, any>, string, string>>(config?: MockRestApiQueryConfig<Document_1>) => prismicT.Query<Document_1>;
+
+declare type MockRestApiTagsConfig = MockRestApiConfig;
+declare const tags: (config?: MockRestApiTagsConfig) => prismicT.Tags<string>;
+
+declare const index$1_repository: typeof repository;
+type index$1_MockRestApiRepositoryConfig = MockRestApiRepositoryConfig;
+declare const index$1_ref: typeof ref;
+type index$1_MockRestApiRefConfig<_0> = MockRestApiRefConfig<_0>;
+type index$1_MockRestApiRefValue<_0> = MockRestApiRefValue<_0>;
+declare const index$1_query: typeof query;
+type index$1_MockRestApiQueryConfig<_0> = MockRestApiQueryConfig<_0>;
+declare const index$1_tags: typeof tags;
+type index$1_MockRestApiTagsConfig = MockRestApiTagsConfig;
+declare namespace index$1 {
+  export {
+    index$1_repository as repository,
+    index$1_MockRestApiRepositoryConfig as MockRestApiRepositoryConfig,
+    index$1_ref as ref,
+    index$1_MockRestApiRefConfig as MockRestApiRefConfig,
+    index$1_MockRestApiRefValue as MockRestApiRefValue,
+    index$1_query as query,
+    index$1_MockRestApiQueryConfig as MockRestApiQueryConfig,
+    index$1_tags as tags,
+    index$1_MockRestApiTagsConfig as MockRestApiTagsConfig,
+  };
+}
+
 declare type MockBooleanModelConfig = MockModelConfig;
 declare const boolean: (config?: MockBooleanModelConfig) => prismicT.CustomTypeModelBooleanField;
 
 declare type MockColorModelConfig = MockModelConfig;
 declare const color: (config?: MockColorModelConfig) => prismicT.CustomTypeModelColorField;
 
-declare type MockContentRelationshipModelConfig = {
-    constrainCustomTypes?: boolean;
-    constrainTags?: boolean;
-} & MockModelConfig;
-declare const contentRelationship: (config?: MockContentRelationshipModelConfig) => prismicT.CustomTypeModelContentRelationshipField;
-
-declare type MockRichTextModelConfig<WithMultipleBlocks extends boolean = boolean> = {
-    withMultipleBlocks?: WithMultipleBlocks;
+declare type MockContentRelationshipModelConfig<CustomTypeIDs extends string = string, Tags extends string = string> = {
+    customTypeIDs?: readonly CustomTypeIDs[];
+    tags?: readonly Tags[];
 } & MockModelConfig;
-declare const richText: <WithMultipleBlocks extends boolean = boolean>(config?: MockRichTextModelConfig<WithMultipleBlocks>) => WithMultipleBlocks extends true ? prismicT.CustomTypeModelRichTextMultiField : prismicT.CustomTypeModelRichTextSingleField;
+declare const contentRelationship: <CustomTypeIDs extends string, Tags extends string>(config?: MockContentRelationshipModelConfig<CustomTypeIDs, Tags>) => prismicT.CustomTypeModelContentRelationshipField<CustomTypeIDs, Tags>;
 
-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;
@@ -429,14 +368,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;
@@ -444,42 +385,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;
@@ -490,6 +451,9 @@ declare const title: (config?: MockTitleModelConfig) => prismicT.CustomTypeModel
 declare type MockUIDModelConfig = MockModelConfig;
 declare const uid: (config?: MockUIDModelConfig) => prismicT.CustomTypeModelUIDField;
 
+declare type BuildMockGroupFieldMapConfig = MockModelConfig;
+declare const buildMockGroupFieldMap: (config?: BuildMockGroupFieldMapConfig) => GroupFieldModelMap;
+
 declare const index_boolean: typeof boolean;
 declare const index_color: typeof color;
 declare const index_contentRelationship: typeof contentRelationship;
@@ -514,6 +478,7 @@ declare const index_sliceZone: typeof sliceZone;
 declare const index_timestamp: typeof timestamp;
 declare const index_title: typeof title;
 declare const index_uid: typeof uid;
+declare const index_buildMockGroupFieldMap: typeof buildMockGroupFieldMap;
 declare namespace index {
   export {
     index_boolean as boolean,
@@ -540,7 +505,8 @@ declare namespace index {
     index_timestamp as timestamp,
     index_title as title,
     index_uid as uid,
+    index_buildMockGroupFieldMap as buildMockGroupFieldMap,
   };
 }
 
-export { index as model, index$1 as value };
+export { index$1 as api, index as model, index$2 as value };