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

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

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

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

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

package/lib/import/validators/fields/Slices/index.d.ts

@@ -0,0 +1 @@
+export * from "./Slices";

package/lib/import/validators/fields/Slices/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./Slices"), exports);

package/lib/import/validators/fields/Slices/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/Slices/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.d.ts

@@ -0,0 +1,4 @@
+import * as t from "io-ts";
+import { UUID } from "io-ts-types";
+export declare type SliceId = `${string}$${UUID}`;
+export declare const SliceId: t.Type<string, string, unknown>;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SliceId = 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 io_ts_types_1 = require("io-ts-types");
+exports.SliceId = t.string.pipe(new t.Type("SliceId", (u) => typeof u === "string", (u, c) => {
+    const [sliceType, uuid] = u.split("$");
+    return (0, function_1.pipe)(t.string.validate(sliceType, c), E.chain((sliceType) => (0, function_1.pipe)(io_ts_types_1.UUID.validate(uuid, c), E.map((decodedUUID) => `${sliceType}$${decodedUUID}`))));
+}, t.identity));

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

@@ -0,0 +1,6 @@
+import * as t from "io-ts";
+export declare const ImportUID: t.Type<{
+    type: "UID";
+    value: string | null;
+}, string | undefined, unknown>;
+export declare type ImportUID = t.TypeOf<typeof ImportUID>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportUID = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const ImportContent_1 = require("./ImportContent");
+const regex = /^[a-z0-9-_.]+$/;
+const uidValue = validators_1.String.pipe(new t.Type("ImportUIDField", (u) => validators_1.String.is(u), (n, c) => {
+    if (regex.test(n)) {
+        return t.success(n);
+    }
+    return t.failure(n, c, "UID can only contain alphanumeric characters, dashes, underscores, and dots");
+}, t.identity));
+exports.ImportUID = (0, ImportContent_1.ImportContent)("UID", (0, validators_1.NullOrElse)(uidValue));

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

@@ -1,6 +1,2 @@
-import type { FieldType } from "../../../customtypes";
 export * from "./nestable";
-export interface ImportFieldOutput<t extends FieldType, v, d = null> {
-    type: t;
-    value: v | d;
-}
+export * from "./UID";

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

@@ -2,3 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./nestable"), exports);
+(0, tslib_1.__exportStar)(require("./UID"), exports);

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

@@ -0,0 +1,6 @@
+import type { TypeOf } from "io-ts";
+export declare const ImportBoolean: import("io-ts").Type<{
+    type: "Boolean";
+    value: boolean | null;
+}, boolean | undefined, unknown>;
+export declare type ImportBoolean = TypeOf<typeof ImportBoolean>;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportBoolean = void 0;
+const validators_1 = require("../../../../validators");
+const ImportContent_1 = require("../ImportContent");
+exports.ImportBoolean = (0, ImportContent_1.ImportContent)("Boolean", (0, validators_1.NullOrElse)(validators_1.Boolean));

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

@@ -1,5 +1,6 @@
 import * as t from "io-ts";
-import { HexaColorCode } from "../../../../common/HexaColorCode";
-import type { ImportFieldOutput } from "..";
-export declare type ImportColor = ImportFieldOutput<"Color", HexaColorCode>;
-export declare const ImportColor: t.Type<ImportColor, ImportColor, unknown>;
+export declare const ImportColor: t.Type<{
+    type: "Color";
+    value: `#${string}` | null;
+}, string | undefined, unknown>;
+export declare type ImportColor = t.TypeOf<typeof ImportColor>;

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

@@ -5,11 +5,11 @@ const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const HexaColorCode_1 = require("../../../../common/HexaColorCode");
 const validators_1 = require("../../../../validators");
-exports.ImportColor = (0, validators_1.NullOrT)(
-// @ts-expect-error HexaColorCode is not inferred as a string.
-validators_1.String.pipe(new t.Type("ImportColorField", (u) => validators_1.String.is(u) && HexaColorCode_1.HexaColor.is(u), (s, c) => {
+const ImportContent_1 = require("../ImportContent");
+const colorValue = new t.Type("ImportColorValue", (u) => validators_1.String.is(u) && HexaColorCode_1.HexaColor.is(u), (s, c) => {
     if (!HexaColorCode_1.HexaColor.is(s)) {
         return t.failure(s, c, "The color value must be an hexadecimal color code");
     }
     return t.success(s);
-}, t.identity)))((s) => ({ type: "Color", value: s }));
+}, t.identity);
+exports.ImportColor = (0, ImportContent_1.ImportContent)("Color", (0, validators_1.NullOrElse)(validators_1.String.pipe(colorValue)));

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

@@ -1,4 +1,6 @@
 import * as t from "io-ts";
-import type { ImportFieldOutput } from "..";
-export declare type ImportDate = ImportFieldOutput<"Date", Date>;
-export declare const ImportDate: t.Type<ImportDate, ImportDate, unknown>;
+export declare const ImportDate: t.Type<{
+    type: "Date";
+    value: Date | null;
+}, Date | undefined, unknown>;
+export declare type ImportDate = t.TypeOf<typeof ImportDate>;

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

@@ -6,12 +6,14 @@ const Either_1 = 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 DATE_INPUT_REGEX = /^(\d{1,4})-(\d{1,2})-(\d{1,2})$/;
-exports.ImportDate = (0, validators_1.NullOrT)(new t.Type("ImportDate", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(validators_1.String.validate(u, c), (0, Either_1.chain)((s) => {
+const dateValue = new t.Type("ImportNumberValue", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(validators_1.String.validate(u, c), (0, Either_1.chain)((s) => {
     const date = new Date(s);
     const isInvalidDate = isNaN(date.getTime());
     if (isInvalidDate || !DATE_INPUT_REGEX.test(s)) {
         return t.failure(u, c, "The value must be a Date in the format YYYY-MM-DD");
     }
     return t.success(date);
-})), t.identity))((s) => ({ type: "Date", value: s }));
+})), t.identity);
+exports.ImportDate = (0, ImportContent_1.ImportContent)("Date", (0, validators_1.NullOrElse)(dateValue));

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

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+export declare const ImportEmbed: t.Type<{
+    type: "Embed";
+    value: {
+        embed_url: string;
+    } | null;
+}, {
+    embed_url: string;
+} | undefined, unknown>;
+export declare type ImportEmbed = t.TypeOf<typeof ImportEmbed>;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEmbed = 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");
+function isValidHttpUrl(param) {
+    try {
+        if (typeof param !== "string") {
+            return false;
+        }
+        const url = new URL(param);
+        return ["http:", "https:"].includes(url.protocol);
+    }
+    catch (err) {
+        return false;
+    }
+}
+const EmbedUrl = new t.Type("EmbedUrl", (u) => isValidHttpUrl(u), (u, c) => {
+    if (isValidHttpUrl(u)) {
+        return t.success(u);
+    }
+    else {
+        return t.failure(u, c, "The value must be a valid http/https url");
+    }
+}, t.identity);
+const EmbedProto = t.type({
+    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));

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

@@ -0,0 +1,13 @@
+import type { TypeOf } from "io-ts";
+import * as t from "io-ts";
+export declare const ImportGeoPoint: t.Type<{
+    type: "GeoPoint";
+    value: {
+        latitude: number;
+        longitude: number;
+    } | null;
+}, {
+    latitude: number;
+    longitude: number;
+} | undefined, unknown>;
+export declare type ImportGeoPoint = TypeOf<typeof ImportGeoPoint>;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportGeoPoint = 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 ImportContent_1 = require("../ImportContent");
+const GeooPoint = (0, function_1.withFallbackMessage)(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));

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

@@ -0,0 +1,26 @@
+import type { TypeOf } from "io-ts";
+import type { ImageField } from "./model";
+import type { ImageFieldValidator, ThumbnailsValidator } from "./Validator";
+export declare const decodeImageField: (image: TypeOf<typeof ImageFieldValidator> | undefined, mainImage: TypeOf<typeof ImageFieldValidator>, constraints?: {
+    width?: number | null;
+    height?: number | null;
+} | undefined) => ImageField;
+export declare const decodeThumbnails: (mainImage: TypeOf<typeof ImageFieldValidator>, thumbnails: TypeOf<typeof ThumbnailsValidator>, 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) => {};

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeThumbnails = exports.decodeImageField = void 0;
+// This function merges user input with custom type constraints.
+// If `image` is missing, `mainImage` is used for the encoding
+// (case when user input lacks thumbnail definition)
+const decodeImageField = (image, mainImage, constraints) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    const background = (_a = image === null || image === void 0 ? void 0 : image.edit) === null || _a === void 0 ? void 0 : _a.background;
+    const width = (_d = (_b = constraints === null || constraints === void 0 ? void 0 : constraints.width) !== null && _b !== void 0 ? _b : (_c = image === null || image === void 0 ? void 0 : image.dimensions) === null || _c === void 0 ? void 0 : _c.width) !== null && _d !== void 0 ? _d : (_e = mainImage.dimensions) === null || _e === void 0 ? void 0 : _e.width;
+    const height = (_h = (_f = constraints === null || constraints === void 0 ? void 0 : constraints.height) !== null && _f !== void 0 ? _f : (_g = image === null || image === void 0 ? void 0 : image.dimensions) === null || _g === void 0 ? void 0 : _g.height) !== null && _h !== void 0 ? _h : (_j = mainImage.dimensions) === null || _j === void 0 ? void 0 : _j.height;
+    const alt = image === null || image === void 0 ? void 0 : image.alt;
+    const credit = image === null || image === void 0 ? void 0 : image.credit;
+    return {
+        id: (_k = image === null || image === void 0 ? void 0 : image.id) !== null && _k !== void 0 ? _k : mainImage === null || mainImage === void 0 ? void 0 : mainImage.id,
+        edit: {
+            x: (_m = (_l = image === null || image === void 0 ? void 0 : image.edit) === null || _l === void 0 ? void 0 : _l.x) !== null && _m !== void 0 ? _m : 0,
+            y: (_p = (_o = image === null || image === void 0 ? void 0 : image.edit) === null || _o === void 0 ? void 0 : _o.y) !== null && _p !== void 0 ? _p : 0,
+            zoom: (_r = (_q = image === null || image === void 0 ? void 0 : image.edit) === null || _q === void 0 ? void 0 : _q.zoom) !== null && _r !== void 0 ? _r : 1,
+            ...(background !== undefined ? { background } : {}),
+        },
+        dimensions: {
+            ...(width !== undefined ? { width } : {}),
+            ...(height !== undefined ? { height } : {}),
+        },
+        ...(alt !== undefined ? { alt } : {}),
+        ...(credit !== undefined ? { credit } : {}),
+    };
+};
+exports.decodeImageField = decodeImageField;
+// Merges provided thumbnails with custom type constraints.
+// If any thumbnail is missing, it is created using the origin image (`mainImage`)
+const decodeThumbnails = (mainImage, thumbnails, field) => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = field === null || field === void 0 ? void 0 : field.config) === null || _a === void 0 ? void 0 : _a.thumbnails) === null || _b === void 0 ? void 0 : _b.reduce((acc, thumbnail) => ({
+        ...acc,
+        [thumbnail.name]: (0, exports.decodeImageField)(thumbnails[thumbnail.name], mainImage, thumbnail),
+    }), {})) !== null && _c !== void 0 ? _c : {};
+};
+exports.decodeThumbnails = decodeThumbnails;

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

@@ -0,0 +1,37 @@
+import * as t from "io-ts";
+export declare const ImageFieldValidator: t.Type<{
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    credit?: string | null;
+    alt?: string | null;
+}, {
+    [x: string]: unknown;
+}, unknown>;
+export declare const ThumbnailsValidator: t.RecordC<t.StringC, t.Type<{
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    credit?: string | null;
+    alt?: string | null;
+}, {
+    [x: string]: unknown;
+}, unknown>>;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThumbnailsValidator = exports.ImageFieldValidator = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const BasicTypes_1 = require("../../../../../validators/BasicTypes");
+exports.ImageFieldValidator = BasicTypes_1.AnyObject.pipe(t.intersection([
+    t.type({
+        id: BasicTypes_1.String,
+    }),
+    t.partial({
+        dimensions: BasicTypes_1.AnyObject.pipe(t.partial({
+            width: BasicTypes_1.Number,
+            height: BasicTypes_1.Number,
+        })),
+        edit: BasicTypes_1.AnyObject.pipe(t.partial({
+            x: BasicTypes_1.Number,
+            y: BasicTypes_1.Number,
+            zoom: BasicTypes_1.Number,
+            background: BasicTypes_1.String,
+        })),
+        credit: BasicTypes_1.StringOrNull,
+        alt: BasicTypes_1.StringOrNull,
+    }),
+]));
+exports.ThumbnailsValidator = t.record(t.string, exports.ImageFieldValidator);

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

@@ -0,0 +1,26 @@
+import * as t from "io-ts";
+import type { ImageFieldWithThumbnails } from "./model";
+export declare const ImportImage: (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<{
+    type: "Image";
+    value: ImageFieldWithThumbnails | null;
+}, ImageFieldWithThumbnails | undefined, unknown>;
+export declare type ImportImage = t.TypeOf<ReturnType<typeof ImportImage>>;
+export * from "./model";

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportImage = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = 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 Decoder_1 = require("./Decoder");
+const Validator_1 = require("./Validator");
+const ImageField = (field) => new t.Type("ImageField", (u) => Validator_1.ImageFieldValidator.is(u) &&
+    "thumbnails" in u &&
+    Validator_1.ThumbnailsValidator.is(u["thumbnails"]), (u, ctx) => {
+    return (0, function_1.pipe)(Validator_1.ImageFieldValidator.validate(u, ctx), (0, Either_1.chain)((mainImage) => {
+        const { id, dimensions, edit, credit, alt, ...maybeThumbnails } = mainImage;
+        return (0, function_1.pipe)(Validator_1.ThumbnailsValidator.validate(maybeThumbnails, ctx), (0, Either_1.map)((thumbnails) => {
+            var _a;
+            return ({
+                ...(0, Decoder_1.decodeImageField)(mainImage, mainImage, (_a = field === null || field === void 0 ? void 0 : field.config) === null || _a === void 0 ? void 0 : _a.constraint),
+                thumbnails: (0, Decoder_1.decodeThumbnails)(mainImage, thumbnails, field),
+            });
+        }));
+    }));
+}, t.identity);
+const ImportImage = (field) => (0, ImportContent_1.ImportContent)("Image", (0, validators_1.NullOrElse)(ImageField(field)));
+exports.ImportImage = ImportImage;
+(0, tslib_1.__exportStar)(require("./model"), exports);

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

@@ -0,0 +1,18 @@
+export declare type ImageField = {
+    id: string;
+    edit: {
+        x: number;
+        y: number;
+        zoom: number;
+        background?: string;
+    };
+    dimensions: {
+        width?: number;
+        height?: number;
+    };
+    credit?: string | null;
+    alt?: string | null;
+};
+export declare type ImageFieldWithThumbnails = ImageField & {
+    thumbnails: Record<string, ImageField>;
+};

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

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

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

@@ -0,0 +1,45 @@
+import * as t from "io-ts";
+declare const ImageFieldCodec: t.Type<{
+    id: string;
+} & {
+    edit?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom: number;
+        background: string;
+    };
+    credit?: string | null;
+    alt?: string | null;
+}, {
+    [x: string]: unknown;
+}, unknown>;
+declare const ThumbnailsCodec: t.RecordC<t.StringC, t.Type<{
+    id: string;
+} & {
+    edit?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom: number;
+        background: string;
+    };
+    credit?: string | null;
+    alt?: string | null;
+}, {
+    [x: string]: unknown;
+}, unknown>>;
+declare type Thumbnails = t.TypeOf<typeof ThumbnailsCodec>;
+export declare type ImageField = t.TypeOf<typeof ImageFieldCodec>;
+declare type ImageFieldWithThumbnails = ImageField & {
+    thumbnails: Thumbnails;
+};
+declare const ImageFieldWithThumbnails: t.Type<ImageFieldWithThumbnails, ImageFieldWithThumbnails, unknown>;
+export declare const ImportImage: t.Type<{
+    type: "Image";
+    value: ImageFieldWithThumbnails | null;
+}, ImageFieldWithThumbnails | undefined, unknown>;
+export declare type ImportImage = t.TypeOf<typeof ImportImage>;
+export {};

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportImage = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const Objects_1 = require("../../../../utils/Objects");
+const validators_1 = require("../../../../validators");
+const BasicTypes_1 = require("../../../../validators/BasicTypes");
+const ImportContent_1 = require("../ImportContent");
+const ImageFieldCodec = validators_1.AnyObject.pipe(t.intersection([
+    t.type({
+        id: BasicTypes_1.String,
+    }),
+    t.partial({
+        edit: validators_1.AnyObject.pipe(t.strict({
+            x: validators_1.Number,
+            y: validators_1.Number,
+            width: validators_1.Number,
+            height: validators_1.Number,
+            zoom: validators_1.Number,
+            background: BasicTypes_1.String,
+        })),
+        credit: BasicTypes_1.StringOrNull,
+        alt: BasicTypes_1.StringOrNull,
+    }),
+]));
+const ThumbnailsCodec = t.record(t.string, ImageFieldCodec);
+const ImageFieldWithThumbnails = new t.Type("ImageFieldWithThumbnails", (u) => ImageFieldCodec.is(u) &&
+    "thumbnails" in u &&
+    ThumbnailsCodec.is(u["thumbnails"]), (u, ctx) => {
+    return (0, function_1.pipe)(ImageFieldCodec.validate(u, ctx), (0, Either_1.chain)((proto) => {
+        const { id, edit, credit, alt, ...maybeThumbnails } = proto;
+        return (0, function_1.pipe)(ThumbnailsCodec.validate(maybeThumbnails, ctx), (0, Either_1.map)((thumbnails) => (0, Objects_1.withOptionals)({
+            id,
+            thumbnails,
+        }, [
+            ["edit", edit],
+            ["credit", credit],
+            ["alt", alt],
+        ])));
+    }));
+}, t.identity);
+exports.ImportImage = (0, ImportContent_1.ImportContent)("Image", (0, validators_1.NullOrElse)(ImageFieldWithThumbnails));