@prismicio/types-internal 2.2.0-traverse.alpha-1 → 2.2.0-traverse.alpha-3

package/lib/content/fields/slices/SlicesContent.d.ts

@@ -1,5 +1,5 @@
 import * as t from "io-ts";
-import type { ContentPath, TraverseContentFn } from "../../../_internal/utils";
+import { ContentPath, TraverseSliceContentFn, TraverseWidgetContentFn } from "../../../_internal/utils";
 import { type StaticSlices } from "../../../customtypes";
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
 export declare const SlicesContentType = "SliceContentType";
@@ -5095,9 +5095,10 @@ export declare const SlicesContent: t.TypeC<{
     }>>;
 }>;
 export declare type SlicesContent = t.TypeOf<typeof SlicesContent>;
-export declare function traverseSlices({ path, model, content, }: {
+export declare function traverseSlices({ path, key, model, content, }: {
     path: ContentPath;
+    key: string;
     content: SlicesContent;
     model?: StaticSlices | undefined;
-}): (transform: TraverseContentFn) => SlicesContent;
+}): (transformWidget: TraverseWidgetContentFn, transformSlice: TraverseSliceContentFn) => SlicesContent | undefined;
 export {};

package/lib/content/fields/slices/SlicesContent.js

@@ -5,14 +5,15 @@ const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
+const utils_1 = require("../../../_internal/utils");
 const customtypes_1 = require("../../../customtypes");
-const utils_1 = require("../../utils");
-const GroupContent_1 = require("../GroupContent");
+const utils_2 = require("../../utils");
 const CompositeSliceContent_1 = require("./Slice/CompositeSliceContent");
 const SharedSliceContent_1 = require("./Slice/SharedSliceContent");
+const SimpleSliceContent_1 = require("./Slice/SimpleSliceContent");
 const SliceItem_1 = require("./SliceItem");
 exports.SlicesContentType = "SliceContentType";
-const isSlicesContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.SlicesContentType;
+const isSlicesContent = (u) => (0, utils_2.hasContentType)(u) && u.__TYPE__ === exports.SlicesContentType;
 exports.isSlicesContent = isSlicesContent;
 const SlicesLegacy = (ctx) => {
     const codec = t.array((0, SliceItem_1.SlicesItemLegacy)(ctx));
@@ -36,66 +37,130 @@ exports.SlicesContent = t.type({
     __TYPE__: t.literal(exports.SlicesContentType),
     value: t.array(SliceItem_1.SliceItemContent),
 });
-function traverseSlices({ path, model, content, }) {
-    return (transform) => {
+function findSliceModel(slicesPath, model, content) {
+    var _a, _b;
+    const defaultModel = (_b = (_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.choices) === null || _b === void 0 ? void 0 : _b[content.name];
+    // regular case for shared slices
+    const sharedSliceModel = () => {
+        if ((0, SliceItem_1.isSharedSliceItemContent)(content)) {
+            if (defaultModel && (0, customtypes_1.isStaticSharedSlice)(defaultModel)) {
+                const variationDef = defaultModel.variations.find((v) => v.id === content.widget.variation);
+                return variationDef
+                    ? {
+                        type: "SharedSlice",
+                        sliceName: defaultModel.id,
+                        variationId: variationDef.id,
+                        fields: {
+                            primary: variationDef.primary || {},
+                            items: variationDef.items || {},
+                        },
+                    }
+                    : undefined;
+            }
+        }
+        return;
+    };
+    const migratedSliceModel = () => {
+        var _a;
+        const legacyContentPath = utils_1.ContentPath.append(utils_1.ContentPath.serialize(slicesPath), content.name);
+        const migratedSliceModel = Object.values(((_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.choices) || {}).find((sliceModel) => {
+            var _a;
+            if ((0, customtypes_1.isStaticSharedSlice)(sliceModel)) {
+                return !!((_a = sliceModel.legacyPaths) === null || _a === void 0 ? void 0 : _a[legacyContentPath]);
+            }
+            return false;
+        });
+        if (!migratedSliceModel)
+            return;
+        const migratedVariation = migratedSliceModel === null || migratedSliceModel === void 0 ? void 0 : migratedSliceModel.variations.find((v) => { var _a; return v.id === ((_a = migratedSliceModel.legacyPaths) === null || _a === void 0 ? void 0 : _a[legacyContentPath]); });
+        if (!migratedVariation)
+            return;
+        return {
+            type: "SharedSlice",
+            sliceName: migratedSliceModel.id,
+            variationId: migratedVariation.id,
+            fields: {
+                primary: migratedVariation.primary || {},
+                items: migratedVariation.items || {},
+            },
+        };
+    };
+    const legacySliceModel = () => {
+        if (!defaultModel)
+            return;
+        if ((0, customtypes_1.isCompositeSlice)(defaultModel)) {
+            return {
+                type: "Slice",
+                fields: {
+                    "non-repeat": defaultModel["non-repeat"] || {},
+                    repeat: defaultModel.repeat || {},
+                },
+            };
+        }
+        if ((0, customtypes_1.isLegacySlice)(defaultModel)) {
+            return defaultModel;
+        }
+        return;
+    };
+    return sharedSliceModel() || migratedSliceModel() || legacySliceModel();
+}
+function traverseSlices({ path, key, model, content, }) {
+    return (transformWidget, transformSlice) => {
         const value = content.value.reduce((acc, sliceContent) => {
-            var _a, _b;
-            const sliceModel = (_b = (_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.choices) === null || _b === void 0 ? void 0 : _b[sliceContent.name];
-            const slicePath = path.concat({
-                key: sliceContent.key,
-                type: sliceContent.widget.__TYPE__,
-            });
-            const convertedSliceWidget = (() => {
-                switch (sliceContent.widget.__TYPE__) {
-                    case "SharedSliceContent":
-                        return (0, SharedSliceContent_1.traverseSharedSliceContent)({
-                            path: slicePath,
-                            sliceName: sliceContent.name,
-                            model: sliceModel && (0, customtypes_1.isStaticSharedSlice)(sliceModel)
-                                ? sliceModel
-                                : undefined,
-                            content: sliceContent.widget,
-                        })(transform);
-                    case "CompositeSliceContent":
-                        return (0, CompositeSliceContent_1.traverseCompositeSliceContent)({
-                            path: slicePath,
-                            sliceName: sliceContent.name,
-                            model: sliceModel && (0, customtypes_1.isCompositeSlice)(sliceModel)
-                                ? sliceModel
-                                : undefined,
-                            content: sliceContent.widget,
-                        })(transform);
-                    case "GroupContentType":
-                        return (0, GroupContent_1.traverseGroupContent)({
-                            path: slicePath,
-                            model: sliceModel &&
-                                (0, customtypes_1.isLegacySlice)(sliceModel) &&
-                                sliceModel.type === "Group"
-                                ? sliceModel
-                                : undefined,
-                            content: sliceContent.widget,
-                        })(transform);
-                    default:
-                        return sliceContent.widget;
-                }
+            const sliceModel = model && findSliceModel(path, model, sliceContent);
+            const convertedSlice = (() => {
+                if ((0, SliceItem_1.isSharedSliceItemContent)(sliceContent))
+                    return (0, SharedSliceContent_1.traverseSharedSliceContent)({
+                        path: path.concat({
+                            key: sliceContent.key,
+                            type: "SharedSlice",
+                        }),
+                        sliceKey: sliceContent.key,
+                        sliceName: sliceContent.name,
+                        model: (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "SharedSlice" ? sliceModel : undefined,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                if ((0, SliceItem_1.isCompositeSliceItemContent)(sliceContent))
+                    return (0, CompositeSliceContent_1.traverseCompositeSliceContent)({
+                        path: path.concat({
+                            key: sliceContent.key,
+                            type: "Slice",
+                        }),
+                        sliceKey: sliceContent.key,
+                        sliceName: sliceContent.name,
+                        model: (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "Slice" ||
+                            (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "SharedSlice"
+                            ? sliceModel
+                            : undefined,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                if ((0, SliceItem_1.isSimpleSliceItemContent)(sliceContent))
+                    return (0, SimpleSliceContent_1.traverseSimpleSliceContent)({
+                        path: path.concat({
+                            key: sliceContent.key,
+                            type: "LegacySlice",
+                        }),
+                        sliceKey: sliceContent.key,
+                        sliceName: sliceContent.name,
+                        model: sliceModel && (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) !== "Slice"
+                            ? sliceModel
+                            : undefined,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                return;
             })();
-            const convertedSlice = transform({
-                key: sliceContent.key,
-                apiId: sliceContent.name,
-                path: slicePath,
-                model: sliceModel,
-                content: convertedSliceWidget,
-            });
-            const convertedSliceParent = convertedSlice && {
-                ...sliceContent,
-                widget: convertedSlice,
-            };
-            return convertedSliceParent ? acc.concat(convertedSliceParent) : acc;
+            return convertedSlice ? acc.concat(convertedSlice) : acc;
         }, []);
-        return {
-            __TYPE__: content.__TYPE__,
-            value,
-        };
+        return transformWidget({
+            path,
+            key,
+            apiId: key,
+            model,
+            content: {
+                __TYPE__: content.__TYPE__,
+                value,
+            },
+        });
     };
 }
 exports.traverseSlices = traverseSlices;

package/lib/customtypes/CustomType.d.ts

@@ -1344,6 +1344,9 @@ export declare const StaticCustomType: t.ExactC<t.IntersectionC<[t.TypeC<{
                         })[];
                     } & {
                         description?: string;
+                        legacyPaths?: {
+                            [x: string]: string;
+                        };
                     });
                 };
             };
@@ -2395,5 +2398,9 @@ export declare function toStatic(customType: CustomType, sharedSlices: Map<strin
 export declare function validateSlices(customType: CustomType, sharedSlices: Map<string, SharedSlice>): Either<CustomTypeSlicesError, CustomType>;
 export declare function collectWidgets(customType: CustomType, f: (ref: string, widget: DynamicWidget) => DynamicWidget | undefined): CustomType;
 export declare function filterMissingSharedSlices(customType: CustomType, sharedSlices: Map<string, SharedSlice>): CustomType;
-export declare function flattenCustomTypeFields(customType: StaticCustomType): Partial<Record<string, StaticWidget>>;
+export declare function flattenCustomTypeFields(customType: StaticCustomType): Record<string, StaticWidget>;
+export declare function collectSharedSlices(customType: {
+    customTypeId: string;
+    fields: Record<string, StaticWidget>;
+}): Record<string, SharedSlice>;
 export {};

package/lib/customtypes/CustomType.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flattenCustomTypeFields = exports.filterMissingSharedSlices = exports.collectWidgets = exports.validateSlices = exports.toStatic = exports.flattenStaticWidgets = exports.flattenWidgets = exports.CustomType = exports.StaticCustomType = exports.CustomTypeFormat = void 0;
+exports.collectSharedSlices = exports.flattenCustomTypeFields = exports.filterMissingSharedSlices = exports.collectWidgets = exports.validateSlices = exports.toStatic = exports.flattenStaticWidgets = exports.flattenWidgets = exports.CustomType = exports.StaticCustomType = exports.CustomTypeFormat = void 0;
 const tslib_1 = require("tslib");
 const Either_1 = require("fp-ts/lib/Either");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
@@ -147,3 +147,20 @@ function flattenCustomTypeFields(customType) {
     }), {});
 }
 exports.flattenCustomTypeFields = flattenCustomTypeFields;
+function collectSharedSlices(customType) {
+    return Object.entries(customType.fields).reduce((acc, [, w]) => {
+        var _a;
+        if (w.type === "Slices" || w.type === "Choice") {
+            return {
+                ...acc,
+                ...Object.entries(((_a = w.config) === null || _a === void 0 ? void 0 : _a.choices) || {}).reduce((sliceZoneAcc, [sliceKey, sliceModel]) => {
+                    return sliceModel.type === "SharedSlice"
+                        ? { ...sliceZoneAcc, [sliceKey]: sliceModel }
+                        : sliceZoneAcc;
+                }, {}),
+            };
+        }
+        return acc;
+    }, {});
+}
+exports.collectSharedSlices = collectSharedSlices;

package/lib/customtypes/Section.d.ts

@@ -1328,6 +1328,9 @@ export declare const StaticSection: t.RecordC<t.Type<string, string, unknown>, t
                 })[];
             } & {
                 description?: string;
+                legacyPaths?: {
+                    [x: string]: string;
+                };
             });
         };
     };

package/lib/customtypes/diff/SharedSlice.d.ts

@@ -340,6 +340,9 @@ export declare const SliceComparator: {
         })[];
     } & {
         description?: string;
+        legacyPaths?: {
+            [x: string]: string;
+        };
     }) | undefined, sliceB?: ({
         id: string;
         type: "SharedSlice";
@@ -674,5 +677,8 @@ export declare const SliceComparator: {
         })[];
     } & {
         description?: string;
+        legacyPaths?: {
+            [x: string]: string;
+        };
     }) | undefined): SliceDiff | undefined;
 };

package/lib/customtypes/widgets/Widget.d.ts

@@ -1667,6 +1667,9 @@ export declare const StaticWidget: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
                 })[];
             } & {
                 description?: string;
+                legacyPaths?: {
+                    [x: string]: string;
+                };
             });
         };
     };

package/lib/customtypes/widgets/slices/CompositeSlice.d.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts";
+import type { PickOnly } from "../../../_internal/utils";
 import type { DynamicSlice, StaticSlice } from "./Slice";
 export declare const CompositeSliceType = "Slice";
 export declare const CompositeSliceConfig: t.ExactC<t.PartialC<{
@@ -331,4 +332,8 @@ export declare const CompositeSlice: t.ExactC<t.IntersectionC<[t.TypeC<{
     }>>;
 }>]>>;
 export declare type CompositeSlice = t.TypeOf<typeof CompositeSlice>;
+export declare type CompositeSliceFields = {
+    type: "Slice";
+    fields: PickOnly<CompositeSlice, "non-repeat" | "repeat">;
+};
 export declare function isCompositeSlice(slice: DynamicSlice | StaticSlice): slice is CompositeSlice;

package/lib/customtypes/widgets/slices/SharedSlice.d.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts";
+import type { PickOnly } from "../../../_internal/utils";
 import type { SharedSliceRef } from "./SharedSliceRef";
 import type { DynamicSlice, StaticSlice } from "./Slice";
 export declare const Variation: t.ExactC<t.IntersectionC<[t.TypeC<{
@@ -326,6 +327,12 @@ export declare const Variation: t.ExactC<t.IntersectionC<[t.TypeC<{
     }>]>>]>>;
 }>]>>;
 export declare type Variation = t.TypeOf<typeof Variation>;
+export declare type VariationFields = {
+    type: "SharedSlice";
+    sliceName: string;
+    variationId: string;
+    fields: PickOnly<Variation, "primary" | "items">;
+};
 export declare const SharedSliceType = "SharedSlice";
 export declare const SharedSlice: t.ExactC<t.IntersectionC<[t.TypeC<{
     id: t.StringC;
@@ -657,6 +664,7 @@ export declare const SharedSlice: t.ExactC<t.IntersectionC<[t.TypeC<{
     }>]>>>;
 }>, t.PartialC<{
     description: t.StringC;
+    legacyPaths: t.RecordC<t.StringC, t.StringC>;
 }>]>>;
 export declare type SharedSlice = t.TypeOf<typeof SharedSlice>;
 export declare function isStaticSharedSlice(slice: StaticSlice): slice is SharedSlice;

package/lib/customtypes/widgets/slices/SharedSlice.js

@@ -23,6 +23,8 @@ exports.Variation = t.exact(t.intersection([
     }),
 ]));
 exports.SharedSliceType = "SharedSlice";
+const LegacyPath = t.string;
+const VariationId = t.string;
 exports.SharedSlice = t.exact(t.intersection([
     t.type({
         id: t.string,
@@ -32,6 +34,7 @@ exports.SharedSlice = t.exact(t.intersection([
     }),
     t.partial({
         description: t.string,
+        legacyPaths: t.record(LegacyPath, VariationId),
     }),
 ]));
 function isStaticSharedSlice(slice) {

package/lib/customtypes/widgets/slices/Slices.d.ts

@@ -1653,6 +1653,9 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
         })[];
     } & {
         description?: string;
+        legacyPaths?: {
+            [x: string]: string;
+        };
     }, unknown, unknown>]>>;
 }>>;
 export declare type StaticSlicesConfig = t.TypeOf<typeof StaticSlicesConfig>;
@@ -3328,6 +3331,9 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                 })[];
             } & {
                 description?: string;
+                legacyPaths?: {
+                    [x: string]: string;
+                };
             });
         };
     }, unknown, unknown>;

package/lib/import/converters/fields/nestable/Image.d.ts

@@ -1,4 +1,6 @@
 import type { Asset } from "../../../../common";
-import type { ImageContent } from "../../../../content";
+import type { ImageContent, ImageContentView } from "../../../../content";
 import type { ImportImage } from "../../../validators";
+import type { ImportImageBlock } from "../../../validators/fields/nestable/ImportRichText/blocks";
+export declare const imageBlockConverter: (imageBlock: ImportImageBlock, assets: Record<Asset["id"], Asset | undefined>) => ImageContentView;
 export declare const imageConverter: (imageField: ImportImage["value"], assets: Record<Asset["id"], Asset | undefined>) => ImageContent | undefined;

package/lib/import/converters/fields/nestable/Image.js

@@ -1,10 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.imageConverter = void 0;
+exports.imageConverter = exports.imageBlockConverter = void 0;
 const common_1 = require("../../../../common");
 const Objects_1 = require("../../../../utils/Objects");
-function convertImage(imageField, image) {
+function convertImage(inputImage, image) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    // We can do that because anyway all properties being read
+    const imageField = {
+        ...inputImage,
+        edit: "edit" in inputImage
+            ? inputImage.edit
+            : {
+                x: 0,
+                y: 0,
+                zoom: 1,
+            },
+        dimensions: "dimensions" in inputImage ? inputImage.dimensions : {},
+    };
     return (0, Objects_1.withOptionals)({
         origin: {
             id: image.id,
@@ -41,6 +53,10 @@ function convertThumbnails(imageField, assets) {
         };
     }, {});
 }
+const imageBlockConverter = (imageBlock, assets) => {
+    return convertImage(imageBlock, (0, common_1.getAssetOrThrow)(assets)(imageBlock.id));
+};
+exports.imageBlockConverter = imageBlockConverter;
 // All assets from `imageField` must be present in `assets`
 // If not then function will throw an error
 const imageConverter = (imageField, assets) => {

package/lib/import/converters/fields/nestable/Nestable.js

@@ -26,6 +26,8 @@ function convertNestableWidget(field, assets, embeds) {
             return (0, _1.linkConverter)(field.value, assets);
         case "Image":
             return (0, _1.imageConverter)(field.value, assets);
+        case "StructuredText":
+            return (0, _1.richTextConverter)(field.value, assets, embeds);
         default:
             throw new Error(`Unsupported type of nestable converter ${JSON.stringify(field)}`);
     }

package/lib/import/converters/fields/nestable/RichText.d.ts

@@ -0,0 +1,4 @@
+import type { Asset, Embed } from "../../../../common";
+import type { RichTextContent } from "../../../../content";
+import type { ImportRichText } from "../../../validators";
+export declare const richTextConverter: (richTextField: ImportRichText["value"], assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>) => RichTextContent | undefined;

package/lib/import/converters/fields/nestable/RichText.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.richTextConverter = void 0;
+const content_1 = require("../../../../content");
+const Embed_1 = require("./Embed");
+const Image_1 = require("./Image");
+const Link_1 = require("./Link");
+const richTextBlockConverter = (importBlock, assets, embeds) => {
+    var _a, _b, _c;
+    if (importBlock.type === "image") {
+        return {
+            type: importBlock.type,
+            data: (0, Image_1.imageBlockConverter)(importBlock, assets),
+        };
+    }
+    else if (importBlock.type === "embed") {
+        const embedData = (0, Embed_1.embedConverter)(importBlock.oembed, embeds);
+        if (!embedData)
+            throw new Error("Failed to convert embed data");
+        return {
+            type: importBlock.type,
+            data: embedData,
+        };
+    }
+    else {
+        // Text block
+        return {
+            type: importBlock.type,
+            direction: (_a = importBlock.direction) !== null && _a !== void 0 ? _a : "ltr",
+            content: {
+                text: importBlock.text,
+                spans: (_c = (_b = importBlock.spans) === null || _b === void 0 ? void 0 : _b.map((span) => {
+                    const linkData = span.type === "hyperlink"
+                        ? (0, Link_1.linkConverter)(span.data, assets)
+                        : undefined;
+                    return {
+                        type: span.type,
+                        start: span.start,
+                        end: span.end,
+                        data: linkData,
+                    };
+                })) !== null && _c !== void 0 ? _c : [],
+            },
+        };
+    }
+};
+const richTextConverter = (richTextField, assets, embeds) => {
+    if (richTextField === null)
+        return;
+    return {
+        __TYPE__: content_1.RichTextContentType,
+        value: richTextField.map((block) => richTextBlockConverter(block, assets, embeds)),
+    };
+};
+exports.richTextConverter = richTextConverter;

package/lib/import/converters/fields/nestable/index.d.ts

@@ -7,6 +7,7 @@ export * from "./Image";
 export * from "./Link";
 export * from "./Nestable";
 export * from "./Number";
+export * from "./RichText";
 export * from "./Select";
 export * from "./Text";
 export * from "./Timestamp";

package/lib/import/converters/fields/nestable/index.js

@@ -10,6 +10,7 @@ const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./Link"), exports);
 (0, tslib_1.__exportStar)(require("./Nestable"), exports);
 (0, tslib_1.__exportStar)(require("./Number"), exports);
+(0, tslib_1.__exportStar)(require("./RichText"), exports);
 (0, tslib_1.__exportStar)(require("./Select"), exports);
 (0, tslib_1.__exportStar)(require("./Text"), exports);
 (0, tslib_1.__exportStar)(require("./Timestamp"), exports);

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

@@ -50,6 +50,9 @@ export declare const ImportField: {
         }, {
             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<{
@@ -74,6 +77,9 @@ 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: ({

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

@@ -8,7 +8,7 @@ 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.type({
+const SharedSliceShape = t.strict({
     id: fields_1.OptionalSharedSliceId,
     slice_type: validators_1.NonEmptyString,
     name: validators_1.String,

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

@@ -12,7 +12,7 @@ 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.type({
+const SharedSliceTypeShape = t.strict({
     slice_type: validators_1.NonEmptyString,
     slice: customtypes_1.SharedSlice,
 });

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

@@ -12,7 +12,7 @@ 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.type({
+const SharedSliceVariationShape = t.strict({
     variation: validators_1.NonEmptyString,
     data: customtypes_1.Variation,
 });

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

@@ -335,5 +335,8 @@ export declare const findSlice: (slices: SharedSliceCustomType[]) => (sliceId: s
     })[];
 } & {
     description?: string;
+    legacyPaths?: {
+        [x: string]: string;
+    };
 }>;
 export declare const findSliceVariation: (slice: SharedSliceCustomType) => (variation: string) => E.Either<string, Variation>;

package/lib/import/validators/fields/nestable/Embed.d.ts

@@ -1,4 +1,7 @@
 import * as t from "io-ts";
+export declare const ImportEmbedValue: t.ExactC<t.TypeC<{
+    embed_url: t.Type<string, string, unknown>;
+}>>;
 export declare const ImportEmbed: t.Type<{
     type: "Embed";
     value: {

package/lib/import/validators/fields/nestable/Embed.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportEmbed = void 0;
+exports.ImportEmbed = exports.ImportEmbedValue = void 0;
 const tslib_1 = require("tslib");
-const Either = (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 validators_1 = require("../../../../validators");
 const ImportContent_1 = require("../ImportContent");
@@ -27,10 +25,7 @@ const EmbedUrl = new t.Type("EmbedUrl", (u) => isValidHttpUrl(u), (u, c) => {
         return t.failure(u, c, "The value must be a valid http/https url");
     }
 }, t.identity);
-const EmbedProto = t.type({
+exports.ImportEmbedValue = t.strict({
     embed_url: EmbedUrl,
 });
-const Embed = new t.Type("ImportEmbedValue", (u) => EmbedProto.is(u), (u) => {
-    return (0, function_1.pipe)(EmbedProto.decode(u), Either.map((parsed) => ({ embed_url: parsed.embed_url })));
-}, t.identity);
-exports.ImportEmbed = (0, ImportContent_1.ImportContent)("Embed", (0, validators_1.EmptyObjectOrElse)(Embed));
+exports.ImportEmbed = (0, ImportContent_1.ImportContent)("Embed", (0, validators_1.EmptyObjectOrElse)(exports.ImportEmbedValue));