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

package/lib/import/validators/Document.js

@@ -2,71 +2,68 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportDocument = void 0;
 const tslib_1 = require("tslib");
-const Either = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const fp_ts_1 = require("fp-ts");
+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 customtypes_1 = require("../../customtypes");
+const io_ts_types_1 = require("io-ts-types");
 const Objects_1 = require("../../utils/Objects");
-const fields_1 = require("./fields");
-const ImportDocument = (mask) => new t.Type("ImportDocument", (u) => (0, Objects_1.isObject)(u), (raw) => {
-    if (!(0, Objects_1.isObject)(raw)) {
-        const error = {
-            value: raw,
-            context: [],
-            message: "document is not an object",
-        };
-        return Either.left([error]);
-    }
-    // flattening the fields within the tabs
-    const maskFields = Object.values(mask.json).reduce((acc, tab) => ({
+const ImportField_1 = require("./fields/ImportField");
+const rawImportDocument = (0, io_ts_types_1.withMessage)(t.record(t.string, t.unknown), () => "document is not an object");
+function flattenCustomTypeFields(customType) {
+    return Object.values(customType.json).reduce((acc, tab) => ({
         ...acc,
         ...tab,
     }));
-    // Listing all errors for each fields
-    const { document, errors } = Object.entries(raw).reduce((acc, [fieldKey, fieldValue]) => {
-        const maskFieldValue = maskFields[fieldKey];
+}
+function validateField(document, customType) {
+    return (key, content, model) => {
         // the field is not defined in the custom type -> extra field or typo
-        if (!maskFieldValue) {
+        if (!model) {
             const error = {
-                value: fieldValue,
-                context: [{ key: fieldKey, type: t.unknown }],
-                message: `The field ${fieldKey} is not part of the Custom type`,
+                value: content,
+                context: [{ key: key, type: t.unknown }],
+                message: `The field ${key} is not part of the Custom type`,
             };
-            return { ...acc, errors: [...acc.errors, error] };
+            return fp_ts_1.either.left([error]);
         }
         // retrieving the right codec then testing out fieldValue with it.
-        const fieldCodec = getFieldCodec(maskFieldValue);
-        const result = fieldCodec.decode(fieldValue);
-        // returning validation errors
-        if (Either.isLeft(result)) {
-            // error.context is pointing at root when it should point to a `fieldKey`.
-            // We need to override the context to make it right.
-            const errors = result.left.map(error => {
+        const { result, codec } = ImportField_1.ImportField.decode(model)(content);
+        // error.context is pointing at root when it should point to a `fieldKey`.
+        // We need to override the context to make it right.
+        if ((0, Either_1.isLeft)(result)) {
+            const errors = result.left.map((error) => {
                 const contextHead = error.context[0];
                 const context = [
-                    { key: '', actual: raw, type: (0, exports.ImportDocument)(mask) },
+                    { key: "", actual: document, type: (0, exports.ImportDocument)(customType) },
                     contextHead
-                        ? { ...contextHead, key: fieldKey }
-                        : { key: fieldKey, actual: fieldValue, type: fieldCodec },
-                    ...error.context.slice(1)
+                        ? { ...contextHead, key: key }
+                        : { key: key, actual: content, type: codec },
+                    ...error.context.slice(1),
                 ];
                 return { ...error, context };
             });
-            return { ...acc, errors: [...acc.errors, ...errors] };
+            return fp_ts_1.either.left(errors);
         }
-        // registering the field as validated
+        return fp_ts_1.either.right(result.right);
+    };
+}
+function validateDocument(customType, rawDoc) {
+    const fieldModels = flattenCustomTypeFields(customType);
+    const { document, errors } = Object.entries(rawDoc).reduce((acc, [fieldKey, fieldValue]) => {
+        const parsedField = validateField(rawDoc, customType)(fieldKey, fieldValue, fieldModels[fieldKey]);
+        if ((0, Either_1.isLeft)(parsedField))
+            return { ...acc, errors: [...acc.errors, ...parsedField.left] };
         return {
             ...acc,
-            document: { ...acc.document, [fieldKey]: result.right },
+            document: { ...acc.document, [fieldKey]: parsedField.right },
         };
     }, { document: {}, errors: [] });
-    // Returning either the errors of
     if (errors.length > 0)
-        return Either.left(errors);
-    return Either.right(document);
+        return fp_ts_1.either.left(errors);
+    return fp_ts_1.either.right(document);
+}
+const ImportDocument = (customType) => new t.Type("ImportDocument", (u) => (0, Objects_1.isObject)(u), (raw) => {
+    return (0, function_1.pipe)(rawImportDocument.decode(raw), fp_ts_1.either.chain((doc) => validateDocument(customType, doc)));
 }, t.identity);
 exports.ImportDocument = ImportDocument;
-function getFieldCodec(maskValue) {
-    if ((0, customtypes_1.isNestableWidget)(maskValue))
-        return (0, fields_1.getNestableFieldCodec)(maskValue);
-    throw new Error(`Unsupported type of field ${maskValue.type}`);
-}

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

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare const ImportContent: <T extends "Boolean" | "Color" | "Date" | "Embed" | "GeoPoint" | "Image" | "IntegrationFields" | "Link" | "Number" | "Range" | "StructuredText" | "Select" | "Separator" | "Text" | "Timestamp" | "Group" | "Choice" | "Slices" | "UID", A, O = A>(type: T, valueCodec: t.Type<A, O, unknown>) => t.Type<{
+    type: T;
+    value: A;
+}, O, unknown>;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportContent = void 0;
+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 Objects_1 = require("../../../utils/Objects");
+const ImportContent = (type, valueCodec) => new t.Type("ImportField", (u) => {
+    if (!(0, Objects_1.isObject)(u))
+        return false;
+    return type === u["type"] && valueCodec.is(u["value"]);
+}, (u) => {
+    return (0, function_1.pipe)(valueCodec.decode(u), fp_ts_1.either.map((decodedValue) => {
+        return {
+            type,
+            value: decodedValue,
+        };
+    }));
+}, (field) => field.value);
+exports.ImportContent = ImportContent;

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

@@ -0,0 +1,131 @@
+import type { StaticWidget } from "../../../customtypes";
+import { ImportNestable } from "./nestable";
+import { ImportUID } from "./UID";
+export declare type ImportField = ImportUID | ImportNestable;
+export declare const ImportField: {
+    is(u: unknown): u is ImportNestable;
+    decode: (field: StaticWidget) => (content: unknown) => {
+        codec: import("io-ts").Type<{
+            type: "Boolean";
+            value: boolean | null;
+        }, boolean | undefined, unknown> | import("io-ts").Type<{
+            type: "Color";
+            value: `#${string}` | null;
+        }, string | undefined, unknown> | import("io-ts").Type<{
+            type: "Date";
+            value: Date | null;
+        }, Date | undefined, unknown> | import("io-ts").Type<{
+            type: "Embed";
+            value: ({
+                embed_url: string;
+                type: string;
+            } & {
+                version?: string | number | null;
+                title?: string;
+                author_name?: string | null;
+                author_url?: string | null;
+                provider_name?: string | null;
+                provider_url?: string | null;
+                cache_age?: string | number | null;
+                thumbnail_url?: string | null;
+                thumbnail_width?: number | null;
+                thumbnail_height?: number | null;
+                html?: string | null;
+            } & {
+                all: unknown;
+            }) | null;
+        }, ({
+            embed_url: string;
+            type: string;
+        } & {
+            version?: string | number | null;
+            title?: string;
+            author_name?: string | null;
+            author_url?: string | null;
+            provider_name?: string | null;
+            provider_url?: string | null;
+            cache_age?: string | number | null;
+            thumbnail_url?: string | null;
+            thumbnail_width?: number | null;
+            thumbnail_height?: number | null;
+            html?: string | null;
+        } & {
+            all: unknown;
+        }) | undefined, unknown> | import("io-ts").Type<{
+            type: "Image";
+            value: (import("./nestable").ImageField & {
+                thumbnails: Record<string, import("./nestable").ImageField>;
+            }) | null;
+        }, (import("./nestable").ImageField & {
+            thumbnails: Record<string, import("./nestable").ImageField>;
+        }) | undefined, unknown> | import("io-ts").Type<{
+            type: "Number";
+            value: number | null;
+        }, number | undefined, unknown> | import("io-ts").Type<{
+            type: "Select";
+            value: string | null;
+        }, string | undefined, unknown> | import("io-ts").Type<{
+            type: "Text";
+            value: string | null;
+        }, string | undefined, unknown> | import("io-ts").Type<{
+            type: "Timestamp";
+            value: Date | null;
+        }, Date | undefined, unknown>;
+        result: import("fp-ts/lib/Either").Left<import("io-ts").Errors> | import("fp-ts/lib/Either").Right<{
+            type: "Timestamp";
+            value: Date | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Text";
+            value: string | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Select";
+            value: string | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Number";
+            value: number | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Image";
+            value: (import("./nestable").ImageField & {
+                thumbnails: Record<string, import("./nestable").ImageField>;
+            }) | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Embed";
+            value: ({
+                embed_url: string;
+                type: string;
+            } & {
+                version?: string | number | null;
+                title?: string;
+                author_name?: string | null;
+                author_url?: string | null;
+                provider_name?: string | null;
+                provider_url?: string | null;
+                cache_age?: string | number | null;
+                thumbnail_url?: string | null;
+                thumbnail_width?: number | null;
+                thumbnail_height?: number | null;
+                html?: string | null;
+            } & {
+                all: unknown;
+            }) | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Date";
+            value: Date | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Color";
+            value: `#${string}` | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Boolean";
+            value: boolean | null;
+        }>;
+    } | {
+        codec: import("io-ts").Type<{
+            type: "UID";
+            value: string | null;
+        }, string | undefined, unknown>;
+        result: import("io-ts").Validation<{
+            type: "UID";
+            value: string | null;
+        }>;
+    };
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportField = void 0;
+const nestable_1 = require("./nestable");
+const UID_1 = require("./UID");
+exports.ImportField = {
+    is(u) {
+        return UID_1.ImportUID.is(u) || nestable_1.ImportNestable.is(u);
+    },
+    decode: (field) => {
+        return (content) => {
+            switch (field.type) {
+                case "UID":
+                    return { codec: UID_1.ImportUID, result: UID_1.ImportUID.decode(content) };
+                case "Choice":
+                case "Slices":
+                case "Group":
+                    throw new Error(`Unsupported type of field ${field.type}`);
+                default:
+                    return nestable_1.ImportNestable.decode(field)(content);
+            }
+        };
+    },
+};

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,27 @@
+import * as t from "io-ts";
+declare const EmbedProto: t.ExactC<t.IntersectionC<[t.TypeC<{
+    embed_url: t.Type<string, string, unknown>;
+    type: t.StringC;
+}>, t.PartialC<{
+    version: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    title: t.StringC;
+    author_name: t.UnionC<[t.StringC, t.NullC]>;
+    author_url: t.UnionC<[t.StringC, t.NullC]>;
+    provider_name: t.UnionC<[t.StringC, t.NullC]>;
+    provider_url: t.UnionC<[t.StringC, t.NullC]>;
+    cache_age: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+    thumbnail_url: t.UnionC<[t.StringC, t.NullC]>;
+    thumbnail_width: t.UnionC<[t.NumberC, t.NullC]>;
+    thumbnail_height: t.UnionC<[t.NumberC, t.NullC]>;
+    html: t.UnionC<[t.StringC, t.NullC]>;
+}>]>>;
+declare type EmbedProto = t.TypeOf<typeof EmbedProto>;
+declare type Embed = EmbedProto & {
+    all: unknown;
+};
+export declare const ImportEmbed: t.Type<{
+    type: "Embed";
+    value: Embed | null;
+}, Embed | undefined, unknown>;
+export declare type ImportEmbed = t.TypeOf<typeof ImportEmbed>;
+export {};

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

@@ -0,0 +1,54 @@
+"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/lib/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 validators_1 = require("../../../../validators");
+const BasicTypes_1 = require("../../../../validators/BasicTypes");
+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.exact(t.intersection([
+    t.type({
+        embed_url: EmbedUrl,
+        type: BasicTypes_1.String,
+    }),
+    t.partial({
+        version: (0, io_ts_types_1.withMessage)(t.union([t.string, t.number, t.null]), () => "The value must be either string, number or null"),
+        title: BasicTypes_1.String,
+        author_name: BasicTypes_1.StringOrNull,
+        author_url: BasicTypes_1.StringOrNull,
+        provider_name: BasicTypes_1.StringOrNull,
+        provider_url: BasicTypes_1.StringOrNull,
+        cache_age: (0, io_ts_types_1.withMessage)(t.union([t.string, t.number, t.null]), () => "The value must be either string, number or null"),
+        thumbnail_url: BasicTypes_1.StringOrNull,
+        thumbnail_width: BasicTypes_1.NumberOrNull,
+        thumbnail_height: BasicTypes_1.NumberOrNull,
+        html: BasicTypes_1.StringOrNull,
+    }),
+]));
+const embedValue = new t.Type("ImportEmbedValue", (u) => EmbedProto.is(u) && "all" in u, (u) => {
+    return (0, function_1.pipe)(EmbedProto.decode(u), Either.map((parsed) => ({ ...parsed, all: u })));
+}, t.identity);
+exports.ImportEmbed = (0, ImportContent_1.ImportContent)("Embed", (0, validators_1.EmptyObjectOrElse)(embedValue));

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

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+export declare type ImageField = {
+    id: string;
+    edit?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom: number;
+        background: string;
+    };
+    alt?: string | null;
+    credit?: string | null;
+};
+declare type ImageFieldWithThumbnails = ImageField & {
+    thumbnails: Record<string, ImageField>;
+};
+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));

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

@@ -0,0 +1,20 @@
+import type { TypeOf } from "io-ts";
+import * as t from "io-ts";
+export declare const ImportLink: t.Type<{
+    type: "Link";
+    value: ({
+        link_type: "Web";
+        url: string;
+    } & {
+        target?: string;
+    }) | {
+        link_type: "Document";
+        id: string;
+    } | {
+        link_type: "Media";
+        id: string;
+    } | null;
+}, {
+    link_type: "Document" | "Web" | "Media";
+} | undefined, unknown>;
+export declare type ImportLink = TypeOf<typeof ImportLink>;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportLink = 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 io_ts_types_1 = require("io-ts-types");
+const AnyLink = t.type({
+    link_type: (0, io_ts_types_1.withMessage)(t.union([t.literal("Web"), t.literal("Document"), t.literal("Media")]), () => "The value must be one of `Web`, `Document` or `Media`"),
+});
+const WebLink = t.intersection([
+    t.type({
+        link_type: t.literal("Web"),
+        url: validators_1.String,
+    }),
+    t.partial({
+        target: validators_1.String,
+    }),
+]);
+const DocumentLink = t.type({
+    link_type: t.literal("Document"),
+    id: validators_1.String,
+});
+const MediaLink = t.type({
+    link_type: t.literal("Media"),
+    id: validators_1.String,
+});
+const Link = AnyLink.pipe(t.union([WebLink, DocumentLink, MediaLink]));
+exports.ImportLink = (0, ImportContent_1.ImportContent)("Link", (0, validators_1.NullOrElse)(Link));