@prismicio/types-internal 2.2.0-alpha.2 → 2.2.0-alpha.21

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

@@ -1,9 +1,9 @@
 import type { StaticWidget } from "../../../customtypes";
+import { ImportSlices } from "./ImportSlices";
 import { ImportNestable } from "./nestable";
-import { ImportUID } from "./UID";
-export declare type ImportField = ImportUID | ImportNestable;
+export declare type ImportField = ImportSlices | ImportNestable;
 export declare const ImportField: {
-    is(u: unknown): u is ImportNestable;
+    is(u: unknown): u is ImportField;
     decode: (field: StaticWidget) => (content: unknown) => {
         codec: import("io-ts").Type<{
             type: "Boolean";
@@ -16,49 +16,43 @@ export declare const ImportField: {
             value: Date | null;
         }, Date | undefined, unknown> | import("io-ts").Type<{
             type: "Embed";
-            value: ({
+            value: {
                 embed_url: string;
-                type: string;
-            } & {
-                version?: string | number | null;
-                title?: string;
-                author_name?: string | null;
-                author_url?: string | null;
-                provider_name?: string | null;
-                provider_url?: string | null;
-                cache_age?: string | number | null;
-                thumbnail_url?: string | null;
-                thumbnail_width?: number | null;
-                thumbnail_height?: number | null;
-                html?: string | null;
-            } & {
-                all: unknown;
-            }) | null;
-        }, ({
+            } | null;
+        }, {
             embed_url: string;
-            type: string;
-        } & {
-            version?: string | number | null;
-            title?: string;
-            author_name?: string | null;
-            author_url?: string | null;
-            provider_name?: string | null;
-            provider_url?: string | null;
-            cache_age?: string | number | null;
-            thumbnail_url?: string | null;
-            thumbnail_width?: number | null;
-            thumbnail_height?: number | null;
-            html?: string | null;
-        } & {
-            all: unknown;
-        }) | undefined, unknown> | import("io-ts").Type<{
+        } | undefined, unknown> | import("io-ts").Type<{
+            type: "GeoPoint";
+            value: {
+                latitude: number;
+                longitude: number;
+            } | null;
+        }, {
+            latitude: number;
+            longitude: number;
+        } | undefined, unknown> | import("io-ts").Type<{
             type: "Image";
-            value: (import("./nestable").ImageField & {
-                thumbnails: Record<string, import("./nestable").ImageField>;
-            }) | null;
-        }, (import("./nestable").ImageField & {
-            thumbnails: Record<string, import("./nestable").ImageField>;
-        }) | undefined, unknown> | import("io-ts").Type<{
+            value: import("./nestable").ImageFieldWithThumbnails | null;
+        }, import("./nestable").ImageFieldWithThumbnails | undefined, unknown> | import("io-ts").Type<{
+            type: "Link";
+            value: ({
+                link_type: "Web";
+                url: string;
+            } & {
+                target?: string;
+            }) | {
+                link_type: "Document";
+                id: string;
+            } | {
+                link_type: "Media";
+                id: string;
+            } | null;
+        }, {
+            link_type: "Document" | "Web" | "Media";
+        } | undefined, unknown> | import("io-ts").Type<{
+            type: "StructuredText";
+            value: import("./nestable").ImportBlock[] | null;
+        }, unknown[] | undefined, unknown> | import("io-ts").Type<{
             type: "Number";
             value: number | null;
         }, number | undefined, unknown> | import("io-ts").Type<{
@@ -83,31 +77,37 @@ export declare const ImportField: {
         }> | import("fp-ts/lib/Either").Right<{
             type: "Number";
             value: number | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "StructuredText";
+            value: import("./nestable").ImportBlock[] | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Link";
+            value: ({
+                link_type: "Web";
+                url: string;
+            } & {
+                target?: string;
+            }) | {
+                link_type: "Document";
+                id: string;
+            } | {
+                link_type: "Media";
+                id: string;
+            } | null;
         }> | import("fp-ts/lib/Either").Right<{
             type: "Image";
-            value: (import("./nestable").ImageField & {
-                thumbnails: Record<string, import("./nestable").ImageField>;
-            }) | null;
+            value: import("./nestable").ImageFieldWithThumbnails | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "GeoPoint";
+            value: {
+                latitude: number;
+                longitude: number;
+            } | null;
         }> | import("fp-ts/lib/Either").Right<{
             type: "Embed";
-            value: ({
+            value: {
                 embed_url: string;
-                type: string;
-            } & {
-                version?: string | number | null;
-                title?: string;
-                author_name?: string | null;
-                author_url?: string | null;
-                provider_name?: string | null;
-                provider_url?: string | null;
-                cache_age?: string | number | null;
-                thumbnail_url?: string | null;
-                thumbnail_width?: number | null;
-                thumbnail_height?: number | null;
-                html?: string | null;
-            } & {
-                all: unknown;
-            }) | null;
+            } | null;
         }> | import("fp-ts/lib/Either").Right<{
             type: "Date";
             value: Date | null;
@@ -120,12 +120,12 @@ export declare const ImportField: {
         }>;
     } | {
         codec: import("io-ts").Type<{
-            type: "UID";
-            value: string | null;
-        }, string | undefined, unknown>;
+            type: "Slices";
+            value: import("./ImportSlices/SharedSlice").SharedSlice[] | null;
+        }, import("./ImportSlices/SharedSlice").SharedSlice[] | undefined, unknown>;
         result: import("io-ts").Validation<{
-            type: "UID";
-            value: string | null;
+            type: "Slices";
+            value: import("./ImportSlices/SharedSlice").SharedSlice[] | null;
         }>;
     };
 };

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

@@ -1,19 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportField = void 0;
+const ImportSlices_1 = require("./ImportSlices");
 const nestable_1 = require("./nestable");
-const UID_1 = require("./UID");
 exports.ImportField = {
     is(u) {
-        return UID_1.ImportUID.is(u) || nestable_1.ImportNestable.is(u);
+        return exports.ImportField.is(u);
     },
     decode: (field) => {
         return (content) => {
             switch (field.type) {
                 case "UID":
-                    return { codec: UID_1.ImportUID, result: UID_1.ImportUID.decode(content) };
-                case "Choice":
+                    throw new Error(`The field '${field.type}' should be put at the root level of the document`);
                 case "Slices":
+                    return {
+                        codec: (0, ImportSlices_1.ImportSlices)(field),
+                        result: (0, ImportSlices_1.ImportSlices)(field).decode(content),
+                    };
+                case "Choice":
                 case "Group":
                     throw new Error(`Unsupported type of field ${field.type}`);
                 default:

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

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+import type { StaticSlices } from "../../../../customtypes";
+import { SharedSlice } from "./SharedSlice";
+export declare const ImportSlices: (staticSlices: StaticSlices) => t.Type<{
+    type: "Slices";
+    value: SharedSlice[] | null;
+}, SharedSlice[] | undefined, unknown>;
+export declare type ImportSlices = t.TypeOf<ReturnType<typeof ImportSlices>>;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportSlices = 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 validators_1 = require("../../../../validators");
+const ImportContent_1 = require("../ImportContent");
+const SharedSlice_1 = require("./SharedSlice");
+const utils_1 = require("./utils");
+const ImportSlices = (staticSlices) => {
+    const supportedSlices = (0, utils_1.extractSupportedSlices)(staticSlices);
+    // For now we only support the SharedSlice, however if we want to support more in the future
+    // we would have to change the codec here to something like this: t.array(t.union([ImportSharedSlice(sharedSlices), NewSliceCodec(newSliceCustomTypes)])).
+    const SlicesArrayCodec = t.array((0, SharedSlice_1.SharedSlice)(supportedSlices));
+    return (0, ImportContent_1.ImportContent)("Slices", (0, validators_1.EmptyObjectOrElse)(new t.Type("ImportSlices", (u) => SlicesArrayCodec.is(u), (u, c) => {
+        return (0, function_1.pipe)(SlicesArrayCodec.validate(u, c), E.chain((slices) => {
+            // This part might not make sense for all Slice types in the future, but for now we only support the SharedSlice
+            // In case we support more in the future, we would have to filter only the relevant type for this check
+            const sharedSliceDuplicates = (0, utils_1.findImportSharedSliceDuplicateIds)(slices);
+            if (sharedSliceDuplicates.length > 0) {
+                return t.failure(slices, [], `Duplicate slice IDs detected: ${sharedSliceDuplicates.join(", ")}`);
+            }
+            return t.success(slices);
+        }));
+    }, t.identity)));
+};
+exports.ImportSlices = ImportSlices;

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

@@ -0,0 +1,14 @@
+import * as t from "io-ts";
+import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes";
+import { SharedSliceContent, SharedSliceId } from "./fields";
+export declare type SharedSlice = {
+    id: SharedSliceId | null | undefined;
+    slice_type: string;
+    name: string;
+    variation: string;
+    primary: SharedSliceContent | null | undefined;
+    items: SharedSliceContent[] | null | undefined;
+    slice_label: string | null | undefined;
+    version: string | null | undefined;
+};
+export declare const SharedSlice: (sharedSlices: SharedSliceCustomType[]) => t.Type<SharedSlice, SharedSlice, unknown>;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSlice = 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 validators_1 = require("../../../../../validators");
+const function_2 = require("../../../../../validators/function");
+const fields_1 = require("./fields");
+const SharedSliceShape = t.strict({
+    id: fields_1.OptionalSharedSliceId,
+    slice_type: validators_1.NonEmptyString,
+    name: validators_1.String,
+    variation: validators_1.NonEmptyString,
+    primary: t.union([t.undefined, t.null, t.record(validators_1.NonEmptyString, t.unknown)]),
+    items: t.union([
+        t.undefined,
+        t.null,
+        t.array(t.record(validators_1.NonEmptyString, t.unknown)),
+    ]),
+    slice_label: t.union([t.undefined, t.null, validators_1.String]),
+    version: t.union([t.undefined, t.null, validators_1.String]),
+});
+const SharedSlice = (sharedSlices) => new t.Type("SharedSlice", (u) => SharedSliceShape.is(u), (u, c) => (0, function_1.pipe)(
+// We validate the base fields that we can validate directly based on the provided 'sharedSlices'
+t
+    .type({
+    id: fields_1.OptionalSharedSliceId,
+    slice_type: (0, fields_1.SharedSliceType)(sharedSlices),
+    slice_label: t.union([t.undefined, t.null, validators_1.String]),
+    version: t.union([t.undefined, t.null, validators_1.String]),
+})
+    .validate(u, c), E.chain((decoded) => (0, function_1.pipe)(
+// We validate the 'variation' field, for which we need the SharedSlice custom type retrieved in the first step
+t
+    .type({
+    variation: (0, fields_1.SharedSliceVariation)(decoded.slice_type.data),
+})
+    .validate(u, c), E.map(({ variation }) => ({ ...decoded, variation })))), E.chain((decoded) => {
+    var _a, _b;
+    return (0, function_1.pipe)(
+    // We validate the 'primary' and 'items' content fields, for which we need the Variation custom type retrieved in the previous step
+    t
+        .partial({
+        primary: (0, fields_1.SharedSliceContent)(decoded.slice_type.slice_type, "primary", (_a = decoded.variation.data.primary) !== null && _a !== void 0 ? _a : {}),
+        // We need to use this wrapper codec instead of using t.array(SharedSliceContent) directly in order to get proper custom error messages
+        items: (0, function_2.withCustomError)(t.array((0, fields_1.SharedSliceContent)(decoded.slice_type.slice_type, "items", (_b = decoded.variation.data.items) !== null && _b !== void 0 ? _b : {})), () => "The value must be an array"),
+    })
+        .validate(u, c), E.map(({ primary, items }) => ({ ...decoded, primary, items })));
+}), E.map(({ id, slice_type, variation, primary, items, slice_label, version, }) => ({
+    id,
+    slice_type: slice_type.slice_type,
+    name: slice_type.data.name,
+    variation: variation.variation,
+    primary,
+    items,
+    slice_label,
+    version: version !== null && version !== void 0 ? version : variation.data.version,
+}))), t.identity);
+exports.SharedSlice = SharedSlice;

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

@@ -0,0 +1,4 @@
+export declare const SharedSliceErrors: {
+    readonly SliceTypeNotFound: (slice_type: string) => string;
+    readonly VariationNotFound: (variation: string, slice_type: string) => string;
+};

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceErrors = void 0;
+exports.SharedSliceErrors = {
+    SliceTypeNotFound: (slice_type) => `Shared slice '${slice_type}' not found in this slice zone in the document's custom type`,
+    VariationNotFound: (variation, slice_type) => `Variation '${variation}' not found for Slice '${slice_type}'`,
+};

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/SharedSliceContent/SharedSliceContent.d.ts

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+import { WidgetKey } from "../../../../../../../common";
+import type { NestableWidget } from "../../../../../../../customtypes";
+import type { ImportNestable } from "../../../../nestable";
+/**
+ * Represents the object in the 'primary' field or a single item in the 'items' array in the SharedSlice.
+ */
+export declare type SharedSliceContent = Record<WidgetKey, ImportNestable>;
+/**
+ * Builds the decoder for a single entry in the 'primary' field or a single item in the 'items' array in the SharedSlice.
+ *
+ * @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
+ * @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
+ * @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
+ * @constructor
+ */
+export declare const SharedSliceContent: (sliceName: string, sliceContentField: "primary" | "items", sliceFieldModels: Record<WidgetKey, NestableWidget>) => t.Type<SharedSliceContent, SharedSliceContent, unknown>;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceContent = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const common_1 = require("../../../../../../../common");
+const io_ts_1 = require("../../../../../../../utils/io-ts");
+const function_2 = require("../../../../../../../validators/function");
+const SharedSliceContentEntry_1 = require("./SharedSliceContentEntry");
+/**
+ * Builds the decoder for a single entry in the 'primary' field or a single item in the 'items' array in the SharedSlice.
+ *
+ * @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
+ * @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
+ * @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
+ * @constructor
+ */
+const SharedSliceContent = (sliceName, sliceContentField, sliceFieldModels) => new t.Type("SharedSliceContent", (u) => t.record(common_1.WidgetKey, t.unknown).is(u), (u, c) => (0, function_1.pipe)(
+// We first decode the raw content object in the shape of Record<WidgetKey, unknown>
+(0, function_2.withCustomError)(t.UnknownRecord, () => "The value must be an object").validate(u, c), E.chain((rawContent) => (0, function_1.pipe)(
+// We split the object into entries because there is no easy other way to decode each value with a different codec
+Object.entries(rawContent).map((entry) => (0, SharedSliceContentEntry_1.SharedSliceContentEntry)(sliceName, sliceContentField, sliceFieldModels).validate(entry, c)), 
+// We get a validation result for each entry in the content object (t.Validation<SharedSliceContentEntry>[]),
+// however we want to get a single validation result for the whole array of entries (t.Validation<SharedSliceContentEntry[]>).
+io_ts_1.combineValidationResults, 
+// We build the object back from entries if all decoded successfully
+E.map((entries) => entries.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}))))), t.identity);
+exports.SharedSliceContent = SharedSliceContent;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/SharedSliceContentEntry.d.ts

@@ -0,0 +1,43 @@
+import * as t from "io-ts";
+import { WidgetKey } from "../../../../../../../common";
+import type { NestableWidget } from "../../../../../../../customtypes";
+import { ImportNestable } from "../../../../nestable";
+export declare type SharedSliceContentEntry = [WidgetKey, ImportNestable];
+/**
+ * Represents a single entry in the 'primary' field or a single entry in an item in the 'items' array in the SharedSlice. It is used to build the SharedSliceContent type from entries of the import object.
+ *
+ * For example, given the following slice:
+ * 	{
+ *  	"slice_type": "my_slice",
+ *  	"variation": "default",
+ *      "primary": {
+ *      	"slice_text": "abc", // This is one entry
+ *          "slice_text2": "def: // This is another entry
+ *       },
+ *       "items": [
+ *       	   {
+ *             		"slice_number1": 0, // This is one entry
+ *             		"slice_number2": 1	// And this is yet another entry
+ *             }
+ *       ]
+ *  }
+ *
+ *  The 'primary' object is converted to following entries to be decoded:
+ *  [
+ *      ["slice_text", "abc"],
+ *      ["slice_text2", "def"]
+ *  ]
+ *  and the first item in the 'items' array is converted to following entries to be decoded:
+ *  [
+ *    ["slice_number1", 0],
+ *    ["slice_number2", 1]
+ *  ]
+ *
+ *  We decode them as separate entries because each of the values might require a different codec as per what is specified in the SharedSlice custom type.
+ *  In this way we save on the decoding performance in comparison to a scenario where we would decode the whole content object as a record with a union type decoder for each value.
+ *
+ *  @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
+ *  @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
+ *  @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
+ */
+export declare const SharedSliceContentEntry: (sliceName: string, sliceContentField: "primary" | "items", sliceFieldModels: Record<WidgetKey, NestableWidget>) => t.Type<SharedSliceContentEntry, SharedSliceContentEntry, unknown>;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/SharedSliceContentEntry.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceContentEntry = 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 nestable_1 = require("../../../../nestable");
+const errors_1 = require("./errors");
+/**
+ * Represents a single entry in the 'primary' field or a single entry in an item in the 'items' array in the SharedSlice. It is used to build the SharedSliceContent type from entries of the import object.
+ *
+ * For example, given the following slice:
+ * 	{
+ *  	"slice_type": "my_slice",
+ *  	"variation": "default",
+ *      "primary": {
+ *      	"slice_text": "abc", // This is one entry
+ *          "slice_text2": "def: // This is another entry
+ *       },
+ *       "items": [
+ *       	   {
+ *             		"slice_number1": 0, // This is one entry
+ *             		"slice_number2": 1	// And this is yet another entry
+ *             }
+ *       ]
+ *  }
+ *
+ *  The 'primary' object is converted to following entries to be decoded:
+ *  [
+ *      ["slice_text", "abc"],
+ *      ["slice_text2", "def"]
+ *  ]
+ *  and the first item in the 'items' array is converted to following entries to be decoded:
+ *  [
+ *    ["slice_number1", 0],
+ *    ["slice_number2", 1]
+ *  ]
+ *
+ *  We decode them as separate entries because each of the values might require a different codec as per what is specified in the SharedSlice custom type.
+ *  In this way we save on the decoding performance in comparison to a scenario where we would decode the whole content object as a record with a union type decoder for each value.
+ *
+ *  @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
+ *  @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
+ *  @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
+ */
+const SharedSliceContentEntry = (sliceName, sliceContentField, sliceFieldModels) => new t.Type("SharedSliceContentEntry", (u) => t.tuple([common_1.WidgetKey, t.unknown]).is(u) && nestable_1.ImportNestable.is(u[1]), (u, c) => {
+    return (0, function_1.pipe)(t.tuple([common_1.WidgetKey, t.unknown]).validate(u, c), E.chain(([key, content]) => {
+        const model = sliceFieldModels[key];
+        if (!model) {
+            return t.failure([key, content], [...c, { key, actual: content, type: t.unknown }], errors_1.SharedSliceContentErrors.UnknownField(sliceName, sliceContentField, key));
+        }
+        const { codec, result } = nestable_1.ImportNestable.decode(model)(content);
+        return (0, function_1.pipe)(result, E.map((decodedContent) => [
+            key,
+            decodedContent,
+        ]), E.mapLeft((errors) => errors.map((error) => {
+            const context = [
+                ...c,
+                ...error.context.filter(({ key }) => !!key),
+                { key, actual: content, type: codec },
+            ];
+            const updatedError = { ...error, context };
+            return updatedError;
+        })));
+    }));
+}, t.identity);
+exports.SharedSliceContentEntry = SharedSliceContentEntry;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/errors.d.ts

@@ -0,0 +1,4 @@
+import type { SharedSliceContentField } from "./types";
+export declare const SharedSliceContentErrors: {
+    readonly UnknownField: (sliceName: string, contentField: SharedSliceContentField, fieldName: string) => string;
+};

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/errors.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceContentErrors = void 0;
+exports.SharedSliceContentErrors = {
+    UnknownField: (sliceName, contentField, fieldName) => `Unsupported field '${fieldName}'for '${contentField}' content in Shared Slice '${sliceName}'`,
+};

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

@@ -0,0 +1,2 @@
+export * from "./errors";
+export * from "./SharedSliceContent";

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

@@ -0,0 +1,5 @@
+"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("./SharedSliceContent"), exports);

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/types.d.ts

@@ -0,0 +1 @@
+export declare type SharedSliceContentField = "primary" | "items";

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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>;