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

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

@@ -0,0 +1,125 @@
+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;
+            } | null;
+        }, {
+            embed_url: string;
+        } | undefined, unknown> | import("io-ts").Type<{
+            type: "GeoPoint";
+            value: {
+                latitude: number;
+                longitude: number;
+            } | null;
+        }, {
+            latitude: number;
+            longitude: number;
+        } | undefined, unknown> | import("io-ts").Type<{
+            type: "Image";
+            value: import("./nestable").ImageFieldWithThumbnails | null;
+        }, import("./nestable").ImageFieldWithThumbnails | undefined, unknown> | import("io-ts").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> | 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: "Link";
+            value: ({
+                link_type: "Web";
+                url: string;
+            } & {
+                target?: string;
+            }) | {
+                link_type: "Document";
+                id: string;
+            } | {
+                link_type: "Media";
+                id: string;
+            } | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Image";
+            value: import("./nestable").ImageFieldWithThumbnails | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "GeoPoint";
+            value: {
+                latitude: number;
+                longitude: number;
+            } | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Embed";
+            value: {
+                embed_url: string;
+            } | 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,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,62 @@
+import * as t from "io-ts";
+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;
+};
+declare type ImageFieldWithThumbnails = ImageField & {
+    thumbnails: Record<string, ImageField>;
+};
+declare const ImageFieldWithThumbnails: (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";
+} & {
+    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 {};