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

package/lib/content/Document.d.ts

@@ -1,7 +1,7 @@
 import * as t from "io-ts";
 import { ContentPath, TraverseSliceContentFn, TraverseWidgetContentFn } from "../_internal/utils";
 import { WidgetKey } from "../common";
-import { StaticCustomType } from "../customtypes";
+import { type StaticWidget } from "../customtypes";
 import { WidgetContent } from "./fields";
 import { FieldOrSliceType, WithTypes } from "./LegacyContentCtx";
 export declare const Document: t.RecordC<t.Type<string, string, unknown>, t.UnionC<[t.ExactC<t.TypeC<{
@@ -2454,7 +2454,10 @@ declare function extractMetadata(data: {
     slugs: ReadonlyArray<string>;
     uid: string | undefined;
 };
-declare function parseLegacyDocument(legacyDoc: unknown, customType: StaticCustomType): Document | undefined;
+declare function parseLegacyDocument(legacyDoc: unknown, customType: {
+    customTypeId: string;
+    fields: Record<string, StaticWidget>;
+}): Document | undefined;
 declare function encodeToLegacyDocument(document: Document): DocumentLegacy;
 export declare const DocumentLegacy: {
     _codec: (allTypes?: Map<string, "Boolean" | "Color" | "Date" | "Embed" | "GeoPoint" | "Image" | "IntegrationFields" | "Link" | "Number" | "Range" | "StructuredText" | "Select" | "Separator" | "Text" | "Timestamp" | "Group" | "Slice" | "SharedSlice" | "Choice" | "Slices" | "UID"> | undefined) => t.Type<{
@@ -4645,13 +4648,19 @@ export declare const DocumentLegacy: {
  */
 export declare function traverseDocument({ document, model, }: {
     document: Document;
-    model?: StaticCustomType;
+    model?: {
+        customTypeId: string;
+        fields: Record<string, StaticWidget>;
+    };
 }): ({ transformWidget, transformSlice, }: {
     transformWidget?: TraverseWidgetContentFn;
     transformSlice?: TraverseSliceContentFn;
 }) => Document;
 export declare function collectWidgets<W extends WidgetContent>(document: Document, is: (content: WidgetContent, path: ContentPath) => content is W): Record<string, W>;
-export declare function migrateDocument(document: Document, model: StaticCustomType): {
+export declare function migrateDocument(document: Document, customType: {
+    customTypeId: string;
+    fields: Record<string, StaticWidget>;
+}): {
     [x: string]: {
         type: string;
         __TYPE__: "EmptyContent";

package/lib/content/Document.js

@@ -103,11 +103,11 @@ exports.DocumentLegacy = {
 function traverseDocument({ document, model, }) {
     return ({ transformWidget = ({ content }) => content, transformSlice = ({ content }) => content, }) => {
         const fieldModels = model &&
-            (0, customtypes_1.flattenStaticWidgets)(model).reduce((acc, [key, def]) => ({ ...acc, [key]: def }), {});
+            Object.entries(model.fields).reduce((acc, [key, def]) => ({ ...acc, [key]: def }), {});
         return Object.entries(document).reduce((acc, [key, content]) => {
             const fieldModel = fieldModels && fieldModels[key];
             const path = utils_1.ContentPath.make([
-                { key: model === null || model === void 0 ? void 0 : model.id, type: "CustomType" },
+                { key: model === null || model === void 0 ? void 0 : model.customTypeId, type: "CustomType" },
                 { key, type: "Widget" },
             ]);
             const transformedWidget = (() => {
@@ -171,86 +171,19 @@ function collectWidgets(document, is) {
     return collected;
 }
 exports.collectWidgets = collectWidgets;
-function migrateCompositeSlice(model, content) {
-    return {
-        key: content.key,
-        name: model.sliceName,
-        maybeLabel: content.maybeLabel,
-        widget: {
-            __TYPE__: "SharedSliceContent",
-            variation: model.variationId,
-            primary: Object.entries(content.widget.nonRepeat).reduce((acc, [fieldKey, fieldContent]) => {
-                var _a;
-                return ((_a = model.fields.primary) === null || _a === void 0 ? void 0 : _a[fieldKey])
-                    ? { ...acc, [fieldKey]: fieldContent }
-                    : acc;
-            }, {}),
-            items: content.widget.repeat.map((groupItem) => {
-                return {
-                    __TYPE__: "GroupItemContent",
-                    value: groupItem.value.reduce((acc, [fieldKey, fieldContent]) => {
-                        var _a;
-                        return ((_a = model.fields.items) === null || _a === void 0 ? void 0 : _a[fieldKey])
-                            ? acc.concat([[fieldKey, fieldContent]])
-                            : acc;
-                    }, []),
-                };
-            }, []),
-        },
-    };
-}
-function migrateSimpleSlice(model, content) {
-    var _a;
-    if (content.widget.__TYPE__ === "GroupContentType") {
-        return {
-            key: content.key,
-            name: model.sliceName,
-            maybeLabel: content.maybeLabel,
-            widget: {
-                __TYPE__: "SharedSliceContent",
-                variation: model.variationId,
-                primary: {},
-                items: content.widget.value.map((groupItem) => {
-                    return {
-                        __TYPE__: "GroupItemContent",
-                        value: groupItem.value.reduce((acc, [fieldKey, fieldContent]) => {
-                            var _a;
-                            return ((_a = model.fields.items) === null || _a === void 0 ? void 0 : _a[fieldKey])
-                                ? acc.concat([[fieldKey, fieldContent]])
-                                : acc;
-                        }, []),
-                    };
-                }, []),
-            },
-        };
-    }
-    return {
-        key: content.key,
-        name: model.sliceName,
-        maybeLabel: content.maybeLabel,
-        widget: {
-            __TYPE__: "SharedSliceContent",
-            variation: model.variationId,
-            primary: ((_a = model.fields.primary) === null || _a === void 0 ? void 0 : _a[content.name])
-                ? { [content.key]: content.widget }
-                : {},
-            items: [],
-        },
-    };
-}
-function migrateDocument(document, model) {
-    const needsMigration = Object.values((0, customtypes_1.collectSharedSlices)(model)).some((slice) => Boolean(slice.legacyPaths));
+function migrateDocument(document, customType) {
+    const needsMigration = Object.values((0, customtypes_1.collectSharedSlices)(customType)).some((slice) => Boolean(slice.legacyPaths));
     if (!needsMigration)
         return document;
     return traverseDocument({
         document,
-        model,
+        model: customType,
     })({
         transformSlice: ({ content, model }) => {
             if ((0, fields_1.isCompositeSliceItemContent)(content) && (model === null || model === void 0 ? void 0 : model.type) === "SharedSlice")
-                return migrateCompositeSlice(model, content);
+                return (0, fields_1.migrateCompositeSlice)(model, content);
             if ((0, fields_1.isSimpleSliceItemContent)(content) && (model === null || model === void 0 ? void 0 : model.type) === "SharedSlice")
-                return migrateSimpleSlice(model, content);
+                return (0, fields_1.migrateSimpleSlice)(model, content);
             return content;
         },
     });

package/lib/content/fields/slices/Slice/CompositeSliceContent.d.ts

@@ -1709,3 +1709,4 @@ export declare function traverseCompositeSliceContent({ path, sliceKey, sliceNam
     content: CompositeSliceItemContent;
     model?: VariationFields | CompositeSliceFields | undefined;
 }): (transformWidget: TraverseWidgetContentFn, transformSlice: TraverseSliceContentFn) => SharedSliceItemContent | CompositeSliceItemContent | undefined;
+export declare function migrateCompositeSlice(model: VariationFields, content: CompositeSliceItemContent): SharedSliceItemContent;

package/lib/content/fields/slices/Slice/CompositeSliceContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseCompositeSliceContent = exports.CompositeSliceContent = exports.CompositeSliceLegacy = exports.isCompositeSliceContent = exports.CompositeSliceContentType = void 0;
+exports.migrateCompositeSlice = exports.traverseCompositeSliceContent = exports.CompositeSliceContent = exports.CompositeSliceLegacy = exports.isCompositeSliceContent = exports.CompositeSliceContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -131,3 +131,32 @@ function traverseCompositeSliceContent({ path, sliceKey, sliceName, model, conte
     };
 }
 exports.traverseCompositeSliceContent = traverseCompositeSliceContent;
+function migrateCompositeSlice(model, content) {
+    return {
+        key: content.key,
+        name: model.sliceName,
+        maybeLabel: content.maybeLabel,
+        widget: {
+            __TYPE__: "SharedSliceContent",
+            variation: model.variationId,
+            primary: Object.entries(content.widget.nonRepeat).reduce((acc, [fieldKey, fieldContent]) => {
+                var _a;
+                return ((_a = model.fields.primary) === null || _a === void 0 ? void 0 : _a[fieldKey])
+                    ? { ...acc, [fieldKey]: fieldContent }
+                    : acc;
+            }, {}),
+            items: content.widget.repeat.map((groupItem) => {
+                return {
+                    __TYPE__: "GroupItemContent",
+                    value: groupItem.value.reduce((acc, [fieldKey, fieldContent]) => {
+                        var _a;
+                        return ((_a = model.fields.items) === null || _a === void 0 ? void 0 : _a[fieldKey])
+                            ? acc.concat([[fieldKey, fieldContent]])
+                            : acc;
+                    }, []),
+                };
+            }, []),
+        },
+    };
+}
+exports.migrateCompositeSlice = migrateCompositeSlice;

package/lib/content/fields/slices/Slice/SimpleSliceContent.d.ts

@@ -1699,3 +1699,4 @@ export declare function traverseSimpleSliceContent({ path, sliceKey, sliceName,
     content: SimpleSliceItemContent;
     model?: VariationFields | Group | NestableWidget | undefined;
 }): (transformWidget: TraverseWidgetContentFn, transformSlice: TraverseSliceContentFn) => SharedSliceItemContent | SimpleSliceItemContent | undefined;
+export declare function migrateSimpleSlice(model: VariationFields, content: SimpleSliceItemContent): SharedSliceItemContent;

package/lib/content/fields/slices/Slice/SimpleSliceContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseSimpleSliceContent = exports.SimpleSliceLegacy = exports.isSimpleSliceContent = exports.SimpleSliceContent = void 0;
+exports.migrateSimpleSlice = exports.traverseSimpleSliceContent = exports.SimpleSliceLegacy = exports.isSimpleSliceContent = exports.SimpleSliceContent = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const GroupContent_1 = require("../../GroupContent");
@@ -85,3 +85,43 @@ function traverseSimpleSliceContent({ path, sliceKey, sliceName, model, content,
     };
 }
 exports.traverseSimpleSliceContent = traverseSimpleSliceContent;
+function migrateSimpleSlice(model, content) {
+    var _a;
+    if (content.widget.__TYPE__ === "GroupContentType") {
+        return {
+            key: content.key,
+            name: model.sliceName,
+            maybeLabel: content.maybeLabel,
+            widget: {
+                __TYPE__: "SharedSliceContent",
+                variation: model.variationId,
+                primary: {},
+                items: content.widget.value.map((groupItem) => {
+                    return {
+                        __TYPE__: "GroupItemContent",
+                        value: groupItem.value.reduce((acc, [fieldKey, fieldContent]) => {
+                            var _a;
+                            return ((_a = model.fields.items) === null || _a === void 0 ? void 0 : _a[fieldKey])
+                                ? acc.concat([[fieldKey, fieldContent]])
+                                : acc;
+                        }, []),
+                    };
+                }, []),
+            },
+        };
+    }
+    return {
+        key: content.key,
+        name: model.sliceName,
+        maybeLabel: content.maybeLabel,
+        widget: {
+            __TYPE__: "SharedSliceContent",
+            variation: model.variationId,
+            primary: ((_a = model.fields.primary) === null || _a === void 0 ? void 0 : _a[content.name])
+                ? { [content.key]: content.widget }
+                : {},
+            items: [],
+        },
+    };
+}
+exports.migrateSimpleSlice = migrateSimpleSlice;

package/lib/customtypes/CustomType.d.ts

@@ -2398,6 +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 collectSharedSlices(customType: StaticCustomType): Record<string, SharedSlice>;
+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

@@ -148,7 +148,7 @@ function flattenCustomTypeFields(customType) {
 }
 exports.flattenCustomTypeFields = flattenCustomTypeFields;
 function collectSharedSlices(customType) {
-    return flattenStaticWidgets(customType).reduce((acc, [, w]) => {
+    return Object.entries(customType.fields).reduce((acc, [, w]) => {
         var _a;
         if (w.type === "Slices" || w.type === "Choice") {
             return {

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

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

@@ -6,8 +6,8 @@ const t = (0, tslib_1.__importStar)(require("io-ts"));
 const validators_1 = require("../../../../validators");
 const function_1 = require("../../../../validators/function");
 const ImportContent_1 = require("../ImportContent");
-const GeooPoint = (0, function_1.withCustomError)(t.strict({
+const GeoPoint = (0, function_1.withCustomError)(t.strict({
     latitude: (0, validators_1.NumberRange)(-90, 90, "latitude"),
     longitude: (0, validators_1.NumberRange)(-180, 180, "longitude"),
 }), () => "GeoPoint must be an object with the properties `latitude` and `longitude` between the given ranges");
-exports.ImportGeoPoint = (0, ImportContent_1.ImportContent)("GeoPoint", (0, validators_1.EmptyObjectOrElse)(GeooPoint));
+exports.ImportGeoPoint = (0, ImportContent_1.ImportContent)("GeoPoint", (0, validators_1.EmptyObjectOrElse)(GeoPoint));

package/lib/import/validators/fields/nestable/Image/default.d.ts

@@ -0,0 +1,22 @@
+import * as t from "io-ts";
+export declare const defaultImportImage: (field?: ({
+    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;
+        })[];
+    };
+}) | undefined) => t.Type<Record<never, never>, {
+    [key: string]: unknown;
+}, unknown>;

package/lib/import/validators/fields/nestable/Image/default.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultImportImage = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../validators");
+const function_1 = require("../../../../../validators/function");
+const defaultImportImage = (field) => {
+    var _a;
+    // If there is not thumbnails we expect an empty object
+    if (!((_a = field === null || field === void 0 ? void 0 : field.config) === null || _a === void 0 ? void 0 : _a.thumbnails) || !field.config.thumbnails.length)
+        return validators_1.EmptyObject;
+    // If there are thumbnails, we expect an object with thumbnails as empty objects
+    return (0, function_1.withCustomError)(t.strict(field.config.thumbnails.reduce((acc, thumbnail) => ({
+        ...acc,
+        [thumbnail.name]: validators_1.EmptyObject,
+    }), {})), () => "The value must be an object");
+};
+exports.defaultImportImage = defaultImportImage;

package/lib/import/validators/fields/nestable/Image/index.d.ts

@@ -1,5 +1,24 @@
 import * as t from "io-ts";
 import type { ImageFieldWithThumbnails } from "./model";
+export declare const ImageFieldCodec: (field?: ({
+    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;
+        })[];
+    };
+}) | undefined) => t.Type<ImageFieldWithThumbnails, ImageFieldWithThumbnails, unknown>;
 export declare const ImportImage: (field?: ({
     type: "Image";
 } & {