@prismicio/types-internal 2.2.1 → 2.3.0

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

@@ -0,0 +1,141 @@
+import type { StaticWidget } from "../../../customtypes";
+import { ImportGroup } from "./ImportGroup";
+import { ImportSlices } from "./ImportSlices";
+import { ImportNestable } from "./nestable";
+export declare type ImportField = ImportSlices | ImportNestable | ImportGroup;
+export declare const ImportField: {
+    is(u: unknown): u is ImportField;
+    decode: (field: StaticWidget) => (content: unknown) => {
+        codec: import("io-ts").Type<{
+            type: "Boolean";
+            value: boolean | null;
+        }, boolean | undefined, unknown> | import("io-ts").Type<{
+            type: "Color";
+            value: `#${string}` | null;
+        }, string | undefined, unknown> | import("io-ts").Type<{
+            type: "Date";
+            value: Date | null;
+        }, Date | undefined, unknown> | import("io-ts").Type<{
+            type: "Embed";
+            value: {
+                embed_url: string;
+            } | null;
+        }, {
+            embed_url: string;
+        } | 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").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;
+        }, import("./nestable").ImportBlock[] | undefined, unknown> | import("io-ts").Type<{
+            type: "Number";
+            value: number | null;
+        }, number | undefined, unknown> | import("io-ts").Type<{
+            type: "Select";
+            value: string | null;
+        }, string | undefined, unknown> | import("io-ts").Type<{
+            type: "Text";
+            value: string | null;
+        }, string | undefined, unknown> | import("io-ts").Type<{
+            type: "Timestamp";
+            value: Date | null;
+        }, Date | undefined, unknown>;
+        result: import("fp-ts/lib/Either").Left<import("io-ts").Errors> | import("fp-ts/lib/Either").Right<{
+            type: "Timestamp";
+            value: Date | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Text";
+            value: string | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Select";
+            value: string | null;
+        }> | 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").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: {
+                embed_url: string;
+            } | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Date";
+            value: Date | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Color";
+            value: `#${string}` | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Boolean";
+            value: boolean | null;
+        }>;
+    } | {
+        codec: import("io-ts").Type<{
+            type: "Slices";
+            value: import("./ImportSlices/SharedSlice").SharedSlice[] | null;
+        }, import("./ImportSlices/SharedSlice").SharedSlice[] | undefined, unknown>;
+        result: import("io-ts").Validation<{
+            type: "Slices";
+            value: import("./ImportSlices/SharedSlice").SharedSlice[] | null;
+        }>;
+    } | {
+        codec: import("io-ts").Type<{
+            type: "Group";
+            value: import("./RepeatableZoneItem").RepeatableZoneItem[] | null;
+        }, import("./RepeatableZoneItem").RepeatableZoneItem[] | undefined, unknown>;
+        result: import("io-ts").Validation<{
+            type: "Group";
+            value: import("./RepeatableZoneItem").RepeatableZoneItem[] | null;
+        }>;
+    };
+};

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportField = void 0;
+const ImportGroup_1 = require("./ImportGroup");
+const ImportSlices_1 = require("./ImportSlices");
+const nestable_1 = require("./nestable");
+exports.ImportField = {
+    is(u) {
+        return exports.ImportField.is(u);
+    },
+    decode: (field) => {
+        return (content) => {
+            switch (field.type) {
+                case "UID":
+                    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 "Group":
+                    return {
+                        codec: (0, ImportGroup_1.ImportGroup)(field),
+                        result: (0, ImportGroup_1.ImportGroup)(field).decode(content),
+                    };
+                case "Choice":
+                    throw new Error(`Unsupported type of field ${field.type}`);
+                default:
+                    return nestable_1.ImportNestable.decode(field)(content);
+            }
+        };
+    },
+};

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

@@ -0,0 +1,345 @@
+import * as t from "io-ts";
+export declare const ImportGroupValue: (groupCustomType?: ({
+    type: "Group";
+} & {
+    fieldset?: string | null | undefined;
+    icon?: string;
+    description?: string;
+    config?: {
+        label?: string | null | undefined;
+        repeat?: boolean;
+        fields?: {
+            [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;
+                };
+            });
+        };
+    };
+}) | undefined) => t.Type<import("./RepeatableZoneItem").RepeatableZoneItem[], import("./RepeatableZoneItem").RepeatableZoneItem[], unknown>;
+export declare const ImportGroup: (groupCustomType?: ({
+    type: "Group";
+} & {
+    fieldset?: string | null | undefined;
+    icon?: string;
+    description?: string;
+    config?: {
+        label?: string | null | undefined;
+        repeat?: boolean;
+        fields?: {
+            [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;
+                };
+            });
+        };
+    };
+}) | undefined) => t.Type<{
+    type: "Group";
+    value: import("./RepeatableZoneItem").RepeatableZoneItem[] | null;
+}, import("./RepeatableZoneItem").RepeatableZoneItem[] | undefined, unknown>;
+export declare type ImportGroup = t.TypeOf<ReturnType<typeof ImportGroup>>;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportGroup = exports.ImportGroupValue = 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 ImportContent_1 = require("./ImportContent");
+const RepeatableZone_1 = require("./RepeatableZone");
+const ImportGroupValue = (groupCustomType) => {
+    var _a, _b;
+    const fieldsModel = (_b = (_a = groupCustomType === null || groupCustomType === void 0 ? void 0 : groupCustomType.config) === null || _a === void 0 ? void 0 : _a.fields) !== null && _b !== void 0 ? _b : {};
+    const groupArrayCodec = (0, RepeatableZone_1.RepeatableZone)(fieldsModel);
+    return (0, function_2.withCustomError)(new t.Type(groupArrayCodec.name, groupArrayCodec.is, (u, c) => (0, function_1.pipe)(groupArrayCodec.validate(u, c), E.chain((groups) => {
+        var _a;
+        if (((_a = groupCustomType === null || groupCustomType === void 0 ? void 0 : groupCustomType.config) === null || _a === void 0 ? void 0 : _a.repeat) === false &&
+            groups.length > 1) {
+            return t.failure(groups, c, "The custom type for this group field does not allow multiple group items");
+        }
+        return t.success(groups);
+    })), t.identity), () => "The group field value must be an array");
+};
+exports.ImportGroupValue = ImportGroupValue;
+const ImportGroup = (groupCustomType) => (0, ImportContent_1.ImportContent)("Group", (0, validators_1.EmptyArrayOrElse)((0, exports.ImportGroupValue)(groupCustomType)));
+exports.ImportGroup = ImportGroup;

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,30 @@
+"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 SharedSliceCodec = (0, SharedSlice_1.SharedSlice)(supportedSlices);
+    const SlicesArrayCodec = t.array(SharedSliceCodec);
+    return (0, ImportContent_1.ImportContent)("Slices", (0, validators_1.EmptyArrayOrElse)(new t.ArrayType(SlicesArrayCodec.name, (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, SharedSliceCodec)));
+};
+exports.ImportSlices = ImportSlices;

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

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes";
+import { RepeatableZone } from "../../RepeatableZone";
+import { RepeatableZoneItem } from "../../RepeatableZoneItem";
+import { SharedSliceId } from "./fields";
+export declare type SharedSlice = {
+    id: SharedSliceId | null | undefined;
+    slice_type: string;
+    name: string;
+    variation: string;
+    primary: RepeatableZoneItem | null | undefined;
+    items: RepeatableZone | 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 RepeatableZone_1 = require("../../RepeatableZone");
+const RepeatableZoneItem_1 = require("../../RepeatableZoneItem");
+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, RepeatableZoneItem_1.RepeatableZoneItem)((_a = decoded.variation.data.primary) !== null && _a !== void 0 ? _a : {}),
+        items: (0, RepeatableZone_1.RepeatableZone)((_b = decoded.variation.data.items) !== null && _b !== void 0 ? _b : {}),
+    })
+        .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}'`,
+};