@prismicio/types-internal 2.2.1 → 2.3.0

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/OptionalSharedSliceId.d.ts

@@ -0,0 +1,2 @@
+import * as t from "io-ts";
+export declare const OptionalSharedSliceId: t.Type<string | null | undefined, string | null | undefined, unknown>;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/OptionalSharedSliceId.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalSharedSliceId = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const SharedSliceId_1 = require("./SharedSliceId");
+// Wrapping the 'SharedSliceId' codec in an optional codec here for the sake of error reporting.
+// When using t.union([t.undefined, t.null, SharedSliceId]) we get a nested error context
+// with the actual decoding error at position 2 in the context array.
+// To avoid mutating the error context we create this new wrapper codec so that  the error context will always have desired depth.
+exports.OptionalSharedSliceId = new t.Type("OptionalSharedSliceId", (u) => u === null || u === undefined || SharedSliceId_1.SharedSliceId.is(u), (u, c) => {
+    if (u === null || u === undefined)
+        return t.success(u);
+    return SharedSliceId_1.SharedSliceId.validate(u, c);
+}, t.identity);

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceId.d.ts

@@ -0,0 +1,9 @@
+import * as t from "io-ts";
+import { UUID } from "../../../../../../common/UUID";
+export declare type SharedSliceId = `${string}$${UUID}`;
+export declare const SharedSliceIdValidationError: {
+    readonly Base: "Slice id must be a non empty string matching the following pattern 'slice_type$uuid'";
+    readonly IncorrectUUID: (uuid: string | undefined) => string;
+    readonly IncorrectSliceType: (sliceType: string | undefined) => string;
+};
+export declare const SharedSliceId: t.Type<string, string, unknown>;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceId.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceId = exports.SharedSliceIdValidationError = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const UUID_1 = require("../../../../../../common/UUID");
+const validators_1 = require("../../../../../../validators");
+const baseErrorText = "Slice id must be a non empty string matching the following pattern 'slice_type$uuid'";
+exports.SharedSliceIdValidationError = {
+    Base: baseErrorText,
+    IncorrectUUID: (uuid) => `Incorrect UUID: '${uuid}' - ${baseErrorText}`,
+    IncorrectSliceType: (sliceType) => `Incorrect slice_type: '${sliceType}' - ${baseErrorText}`,
+};
+exports.SharedSliceId = new t.Type("SharedSliceId", (u) => {
+    if (typeof u !== "string") {
+        return false;
+    }
+    const [sliceName, uuid] = u.split("$");
+    return validators_1.NonEmptyString.is(sliceName) && UUID_1.UUID.is(uuid);
+}, (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.mapLeft((errors) => errors.map((error) => ({
+    ...error,
+    message: exports.SharedSliceIdValidationError.Base,
+}))), E.chain((sliceId) => {
+    const [sliceName, uuid] = sliceId.split("$");
+    return (0, function_1.pipe)(t.tuple([validators_1.NonEmptyString, UUID_1.UUID]).validate([sliceName, uuid], c), E.mapLeft((errors) => errors.map((error) => {
+        const tupleErrorContext = error.context[error.context.length - 1];
+        return {
+            ...error,
+            context: [
+                ...error.context.slice(0, -1), // We don't want the tuple decoder error context
+            ],
+            message: (tupleErrorContext === null || tupleErrorContext === void 0 ? void 0 : tupleErrorContext.key) === "0"
+                ? exports.SharedSliceIdValidationError.IncorrectSliceType(sliceName)
+                : exports.SharedSliceIdValidationError.IncorrectUUID(uuid),
+        };
+    })));
+}), E.map(([sliceName, uuid]) => `${sliceName}$${uuid}`)), (sliceId) => sliceId);

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceType.d.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { SharedSlice as SharedSliceCustomType } from "../../../../../../customtypes";
+export declare type SharedSliceType = {
+    slice_type: string;
+    data: SharedSliceCustomType;
+};
+/**
+ * Builds the decoder for the 'slice_type' field in the SharedSlice. Alongside the decoded 'slice_type' it also returns the SharedSlice data matching the slice_type.
+ * @param slices all the SharedSlices from the custom type
+ */
+export declare const SharedSliceType: (slices: SharedSliceCustomType[]) => t.Type<SharedSliceType, string, unknown>;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceType = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const customtypes_1 = require("../../../../../../customtypes");
+const validators_1 = require("../../../../../../validators");
+const utils_1 = require("../utils");
+/**
+ * slice_type - the validated slice_type
+ * slice - SharedSlice custom type data matching the slice_type. We return it alongside the validated slice_type, because it is needed to decode the 'variation' field in the SharedSlice (see SharedSliceVariation.ts)
+ */
+const SharedSliceTypeShape = t.strict({
+    slice_type: validators_1.NonEmptyString,
+    slice: customtypes_1.SharedSlice,
+});
+/**
+ * Builds the decoder for the 'slice_type' field in the SharedSlice. Alongside the decoded 'slice_type' it also returns the SharedSlice data matching the slice_type.
+ * @param slices all the SharedSlices from the custom type
+ */
+const SharedSliceType = (slices) => new t.Type("slice_type", (u) => SharedSliceTypeShape.is(u), (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.chain((slice_type) => (0, function_1.pipe)((0, utils_1.findSlice)(slices)(slice_type), E.fold((err) => t.failure(u, c, err), (data) => t.success({ slice_type, data }))))), ({ slice_type }) => slice_type);
+exports.SharedSliceType = SharedSliceType;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceVariation.d.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { SharedSlice, Variation } from "../../../../../../customtypes";
+export declare type SharedSliceVariation = {
+    variation: string;
+    data: Variation;
+};
+/**
+ * Builds the decoder for the 'variation' field in the SharedSlice. Alongside the decoded 'variation' it also returns the Variation data matching the variation custom type.
+ * @param slice SharedSlice from the custom type
+ */
+export declare const SharedSliceVariation: (slice: SharedSlice) => t.Type<SharedSliceVariation, string, unknown>;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceVariation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceVariation = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const customtypes_1 = require("../../../../../../customtypes");
+const validators_1 = require("../../../../../../validators");
+const utils_1 = require("../utils");
+/**
+ * variation - the validated variation of the slice
+ * data - Variation data matching the variation. We return it alongside the validated variation, because it is needed to decode the 'primary' and 'items' fields in the SharedSlice.
+ */
+const SharedSliceVariationShape = t.strict({
+    variation: validators_1.NonEmptyString,
+    data: customtypes_1.Variation,
+});
+/**
+ * Builds the decoder for the 'variation' field in the SharedSlice. Alongside the decoded 'variation' it also returns the Variation data matching the variation custom type.
+ * @param slice SharedSlice from the custom type
+ */
+const SharedSliceVariation = (slice) => new t.Type("variation", (u) => SharedSliceVariationShape.is(u), (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.chain((variation) => (0, function_1.pipe)((0, utils_1.findSliceVariation)(slice)(variation), E.fold((err) => t.failure(u, c, err), (data) => t.success({ variation, data }))))), ({ variation }) => variation);
+exports.SharedSliceVariation = SharedSliceVariation;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./OptionalSharedSliceId";
+export * from "./SharedSliceId";
+export * from "./SharedSliceType";
+export * from "./SharedSliceVariation";

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./OptionalSharedSliceId"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSliceId"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSliceType"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSliceVariation"), exports);

package/lib/import/validators/fields/ImportSlices/SharedSlice/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./errors";
+export * from "./fields";
+export * from "./SharedSlice";

package/lib/import/validators/fields/ImportSlices/SharedSlice/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./errors"), exports);
+(0, tslib_1.__exportStar)(require("./fields"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSlice"), exports);

package/lib/import/validators/fields/ImportSlices/SharedSlice/utils.d.ts

@@ -0,0 +1,342 @@
+import * as E from "fp-ts/Either";
+import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes";
+import type { Variation } from "../../../../../customtypes";
+export declare const findSlice: (slices: SharedSliceCustomType[]) => (sliceId: string) => E.Either<string, {
+    id: string;
+    type: "SharedSlice";
+    name: string;
+    variations: readonly ({
+        id: string;
+        name: string;
+        description: string;
+        imageUrl: string;
+        docURL: string;
+        version: string;
+    } & {
+        display?: string;
+        primary?: {
+            [x: string]: ({
+                type: "Boolean";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                    default_value?: boolean;
+                    placeholder_true?: string;
+                    placeholder_false?: string;
+                };
+            }) | ({
+                type: "Color";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Date";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            }) | ({
+                type: "Embed";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                };
+            }) | ({
+                type: "GeoPoint";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Image";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    constraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    thumbnails?: readonly ({
+                        name: string;
+                    } & {
+                        width?: number | null;
+                        height?: number | null;
+                    })[];
+                };
+            }) | ({
+                type: "IntegrationFields";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    catalog?: string;
+                };
+            }) | ({
+                type: "Link";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                    select?: "media" | "document" | "web" | null;
+                    customtypes?: readonly string[];
+                    masks?: readonly string[];
+                    tags?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Number";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "Range";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "StructuredText";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                    single?: string;
+                    multi?: string;
+                    imageConstraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    labels?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Select";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default_value?: string;
+                    options?: readonly string[];
+                };
+            }) | ({
+                type: "Separator";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Text";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Timestamp";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            });
+        };
+        items?: {
+            [x: string]: ({
+                type: "Boolean";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                    default_value?: boolean;
+                    placeholder_true?: string;
+                    placeholder_false?: string;
+                };
+            }) | ({
+                type: "Color";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Date";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            }) | ({
+                type: "Embed";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                };
+            }) | ({
+                type: "GeoPoint";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Image";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    constraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    thumbnails?: readonly ({
+                        name: string;
+                    } & {
+                        width?: number | null;
+                        height?: number | null;
+                    })[];
+                };
+            }) | ({
+                type: "IntegrationFields";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    catalog?: string;
+                };
+            }) | ({
+                type: "Link";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                    select?: "media" | "document" | "web" | null;
+                    customtypes?: readonly string[];
+                    masks?: readonly string[];
+                    tags?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Number";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "Range";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "StructuredText";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                    single?: string;
+                    multi?: string;
+                    imageConstraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    labels?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Select";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default_value?: string;
+                    options?: readonly string[];
+                };
+            }) | ({
+                type: "Separator";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Text";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Timestamp";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            });
+        };
+    })[];
+} & {
+    description?: string;
+    legacyPaths?: {
+        [x: string]: string;
+    };
+}>;
+export declare const findSliceVariation: (slice: SharedSliceCustomType) => (variation: string) => E.Either<string, Variation>;

package/lib/import/validators/fields/ImportSlices/SharedSlice/utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSliceVariation = exports.findSlice = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const errors_1 = require("./errors");
+const findSlice = (slices) => (sliceId) => (0, function_1.pipe)(slices.find((slice) => slice.id === sliceId), E.fromNullable(errors_1.SharedSliceErrors.SliceTypeNotFound(sliceId)));
+exports.findSlice = findSlice;
+const findSliceVariation = (slice) => (variation) => (0, function_1.pipe)(slice.variations.find((v) => v.id === variation), E.fromNullable(errors_1.SharedSliceErrors.VariationNotFound(variation, slice.id)));
+exports.findSliceVariation = findSliceVariation;

package/lib/import/validators/fields/ImportSlices/index.d.ts

@@ -0,0 +1 @@
+export * from "./ImportSlices";

package/lib/import/validators/fields/ImportSlices/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./ImportSlices"), exports);

package/lib/import/validators/fields/ImportSlices/utils.d.ts

@@ -0,0 +1,4 @@
+import { SharedSlice as SharedSliceCustomType, StaticSlices } from "../../../../customtypes";
+import type { SharedSlice, SharedSliceId } from "./SharedSlice";
+export declare const extractSupportedSlices: (staticSlices: StaticSlices) => SharedSliceCustomType[];
+export declare const findImportSharedSliceDuplicateIds: (slices: SharedSlice[]) => SharedSliceId[];

package/lib/import/validators/fields/ImportSlices/utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findImportSharedSliceDuplicateIds = exports.extractSupportedSlices = void 0;
+const tslib_1 = require("tslib");
+const A = (0, tslib_1.__importStar)(require("fp-ts/Array"));
+const function_1 = require("fp-ts/function");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const customtypes_1 = require("../../../../customtypes");
+// Extracts all supported slices from the static slices object
+// For now we only support the SharedSlice, if we want to support other slices in the future, we have to add them here
+const extractSupportedSlices = (staticSlices) => {
+    var _a, _b;
+    return (0, function_1.pipe)(Object.values((_b = (_a = staticSlices.config) === null || _a === void 0 ? void 0 : _a.choices) !== null && _b !== void 0 ? _b : {}).map((slice) => (0, function_1.pipe)(customtypes_1.SharedSlice.decode(slice), O.fromEither)), A.compact);
+};
+exports.extractSupportedSlices = extractSupportedSlices;
+const findImportSharedSliceDuplicateIds = (slices) => {
+    const duplicatesMap = slices.reduce((acc, { id }) => {
+        var _a;
+        if (id) {
+            const currentNumOfDuplicates = (_a = acc[id]) !== null && _a !== void 0 ? _a : 0;
+            return {
+                ...acc,
+                [id]: acc[id] === undefined ? 0 : currentNumOfDuplicates + 1,
+            };
+        }
+        return acc;
+    }, {});
+    return Object.entries(duplicatesMap).flatMap(([id, numOfDuplicates]) => {
+        if (numOfDuplicates > 0) {
+            return [id];
+        }
+        return [];
+    });
+};
+exports.findImportSharedSliceDuplicateIds = findImportSharedSliceDuplicateIds;

package/lib/import/validators/fields/RepeatableZone.d.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import type { WidgetKey } from "../../../common";
+import type { NestableWidget } from "../../../customtypes";
+import { RepeatableZoneItem } from "./RepeatableZoneItem";
+export declare type RepeatableZone = t.TypeOf<ReturnType<typeof RepeatableZone>>;
+/**
+ * A custom type for a repeatable zone. This type of structure can be found 'items' field of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+export declare const RepeatableZone: (fieldModels: Record<WidgetKey, NestableWidget>) => t.ArrayC<t.Type<RepeatableZoneItem, RepeatableZoneItem, unknown>>;

package/lib/import/validators/fields/RepeatableZone.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepeatableZone = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../../validators/function");
+const RepeatableZoneItem_1 = require("./RepeatableZoneItem");
+/**
+ * A custom type for a repeatable zone. This type of structure can be found 'items' field of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+const RepeatableZone = (fieldModels) => (0, function_1.withCustomError)(t.array((0, RepeatableZoneItem_1.RepeatableZoneItem)(fieldModels)), () => "The repeatable zone value must be an array");
+exports.RepeatableZone = RepeatableZone;

package/lib/import/validators/fields/RepeatableZoneItem.d.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { WidgetKey } from "../../../common";
+import type { NestableWidget } from "../../../customtypes";
+import { ImportNestable } from "./nestable";
+export declare type RepeatableZoneItem = Record<WidgetKey, ImportNestable>;
+/**
+ * A custom type for an item of a repeatable zone. This type of structure can be found in the 'primary' and 'items' fields of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+export declare const RepeatableZoneItem: (fieldModels: Record<WidgetKey, NestableWidget>) => t.Type<RepeatableZoneItem, RepeatableZoneItem, unknown>;

package/lib/import/validators/fields/RepeatableZoneItem.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepeatableZoneItem = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const common_1 = require("../../../common");
+const function_2 = require("../../../validators/function");
+const nestable_1 = require("./nestable");
+/**
+ * A custom type for an item of a repeatable zone. This type of structure can be found in the 'primary' and 'items' fields of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+const RepeatableZoneItem = (fieldModels) => new t.Type("RepeatableZoneItem", (u) => t.record(common_1.WidgetKey, t.unknown).is(u) &&
+    Object.values(u).reduce((acc, value) => acc && nestable_1.ImportNestable.is(value), true), (u, c) => {
+    const codecEntries = Object.entries(fieldModels).map(([key, model]) => [key, nestable_1.ImportNestable.getCodec(model)]);
+    const groupCodec = (0, function_2.withCustomError)(t.partial({
+        ...Object.fromEntries(codecEntries),
+    }), () => "The value must be an object");
+    return (0, function_1.pipe)(groupCodec.validate(u, c), E.chain((decodedContent) => {
+        // Validate if all fields are present in the model
+        const keys = Object.keys(decodedContent);
+        const errors = keys.flatMap((key) => fieldModels[key]
+            ? []
+            : [
+                {
+                    value: decodedContent[key],
+                    context: c,
+                    message: `The field '${key}' is not defined in the custom type`,
+                },
+            ]);
+        return errors.length > 0
+            ? t.failures(errors)
+            : t.success(decodedContent); // We can never have a key with decoded value 'undefined' so we can ignore the type derived from t.partial
+    }));
+}, t.identity);
+exports.RepeatableZoneItem = RepeatableZoneItem;