@prismicio/types-internal 2.2.0-alpha.10 → 2.2.0-alpha.11

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

@@ -0,0 +1,339 @@
+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;
+}>;
+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/Slices/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/Slices/SharedSlice/SharedSlice.js

@@ -0,0 +1,60 @@
+"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 fields_1 = require("./fields");
+const SharedSliceShape = t.type({
+    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, fields_1.SharedSliceItems)(decoded.slice_type.slice_type, (_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/Slices/SharedSlice/errors.d.ts

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

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceErrors = void 0;
+exports.SharedSliceErrors = {
+    SliceTypeNotFound: (slice_type) => `Shared slice '${slice_type}' not found in document's custom type`,
+    VariationNotFound: (variation, slice_type) => `Variation '${variation}' not found for Slice '${slice_type}'`,
+    InvalidItemsArray: (slice_type) => `Invalid value for 'items' array in Shared Slice '${slice_type}'. Must be an array of key-value records.`,
+};

package/lib/import/validators/fields/Slices/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/Slices/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/Slices/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/Slices/SharedSlice/fields/SharedSliceContent/SharedSliceContent.js

@@ -0,0 +1,38 @@
+"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 io_ts_types_1 = require("io-ts-types");
+const common_1 = require("../../../../../../../common");
+const io_ts_1 = require("../../../../../../../utils/io-ts");
+const errors_1 = require("./errors");
+const SharedSliceContentEntry_1 = require("./SharedSliceContentEntry");
+/**
+ * Builds the decoder for the raw content object 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
+ */
+const RawContent = (sliceName, sliceContentField) => (0, io_ts_types_1.withMessage)(t.record(common_1.WidgetKey, t.unknown), () => errors_1.SharedSliceContentErrors.InvalidSliceItemContent(sliceName, sliceContentField));
+/**
+ * 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>
+RawContent(sliceName, sliceContentField).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/Slices/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>;