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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceType = 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 customtypes_1 = require("../../../../../../customtypes");
+const validators_1 = require("../../../../../../validators");
+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.strict({
+    slice_type: validators_1.NonEmptyString,
+    slice: customtypes_1.SharedSlice,
+});
+/**
+ * Builds the decoder for the 'slice_type' field in the SharedSlice. Alongside the decoded 'slice_type' it also returns the SharedSlice data matching the slice_type.
+ * @param slices all the SharedSlices from the custom type
+ */
+const SharedSliceType = (slices) => new t.Type("slice_type", (u) => SharedSliceTypeShape.is(u), (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.chain((slice_type) => (0, function_1.pipe)((0, utils_1.findSlice)(slices)(slice_type), E.fold((err) => t.failure(u, c, err), (data) => t.success({ slice_type, data }))))), ({ slice_type }) => slice_type);
+exports.SharedSliceType = SharedSliceType;

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

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { SharedSlice, Variation } from "../../../../../../customtypes";
+export declare type SharedSliceVariation = {
+    variation: string;
+    data: Variation;
+};
+/**
+ * Builds the decoder for the 'variation' field in the SharedSlice. Alongside the decoded 'variation' it also returns the Variation data matching the variation custom type.
+ * @param slice SharedSlice from the custom type
+ */
+export declare const SharedSliceVariation: (slice: SharedSlice) => t.Type<SharedSliceVariation, string, unknown>;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceVariation = 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 customtypes_1 = require("../../../../../../customtypes");
+const validators_1 = require("../../../../../../validators");
+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.strict({
+    variation: validators_1.NonEmptyString,
+    data: customtypes_1.Variation,
+});
+/**
+ * Builds the decoder for the 'variation' field in the SharedSlice. Alongside the decoded 'variation' it also returns the Variation data matching the variation custom type.
+ * @param slice SharedSlice from the custom type
+ */
+const SharedSliceVariation = (slice) => new t.Type("variation", (u) => SharedSliceVariationShape.is(u), (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.chain((variation) => (0, function_1.pipe)((0, utils_1.findSliceVariation)(slice)(variation), E.fold((err) => t.failure(u, c, err), (data) => t.success({ variation, data }))))), ({ variation }) => variation);
+exports.SharedSliceVariation = SharedSliceVariation;

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

@@ -0,0 +1,5 @@
+export * from "./OptionalSharedSliceId";
+export * from "./SharedSliceContent";
+export * from "./SharedSliceId";
+export * from "./SharedSliceType";
+export * from "./SharedSliceVariation";

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./OptionalSharedSliceId"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSliceContent"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSliceId"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSliceType"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSliceVariation"), exports);

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

@@ -0,0 +1,3 @@
+export * from "./errors";
+export * from "./fields";
+export * from "./SharedSlice";

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

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

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

@@ -0,0 +1,339 @@
+import * as E from "fp-ts/Either";
+import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes";
+import type { Variation } from "../../../../../customtypes";
+export declare const findSlice: (slices: SharedSliceCustomType[]) => (sliceId: string) => E.Either<string, {
+    id: string;
+    type: "SharedSlice";
+    name: string;
+    variations: readonly ({
+        id: string;
+        name: string;
+        description: string;
+        imageUrl: string;
+        docURL: string;
+        version: string;
+    } & {
+        display?: string;
+        primary?: {
+            [x: string]: ({
+                type: "Boolean";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                    default_value?: boolean;
+                    placeholder_true?: string;
+                    placeholder_false?: string;
+                };
+            }) | ({
+                type: "Color";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Date";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            }) | ({
+                type: "Embed";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                };
+            }) | ({
+                type: "GeoPoint";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                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;
+                    })[];
+                };
+            }) | ({
+                type: "IntegrationFields";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    catalog?: string;
+                };
+            }) | ({
+                type: "Link";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                    select?: "media" | "document" | "web" | null;
+                    customtypes?: readonly string[];
+                    masks?: readonly string[];
+                    tags?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Number";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "Range";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "StructuredText";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                    single?: string;
+                    multi?: string;
+                    imageConstraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    labels?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Select";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default_value?: string;
+                    options?: readonly string[];
+                };
+            }) | ({
+                type: "Separator";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Text";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Timestamp";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            });
+        };
+        items?: {
+            [x: string]: ({
+                type: "Boolean";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                    default_value?: boolean;
+                    placeholder_true?: string;
+                    placeholder_false?: string;
+                };
+            }) | ({
+                type: "Color";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Date";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            }) | ({
+                type: "Embed";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                };
+            }) | ({
+                type: "GeoPoint";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                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;
+                    })[];
+                };
+            }) | ({
+                type: "IntegrationFields";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    catalog?: string;
+                };
+            }) | ({
+                type: "Link";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                    select?: "media" | "document" | "web" | null;
+                    customtypes?: readonly string[];
+                    masks?: readonly string[];
+                    tags?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Number";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "Range";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "StructuredText";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                    single?: string;
+                    multi?: string;
+                    imageConstraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    labels?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Select";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default_value?: string;
+                    options?: readonly string[];
+                };
+            }) | ({
+                type: "Separator";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Text";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Timestamp";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            });
+        };
+    })[];
+} & {
+    description?: string;
+}>;
+export declare const findSliceVariation: (slice: SharedSliceCustomType) => (variation: string) => E.Either<string, Variation>;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSliceVariation = exports.findSlice = 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 errors_1 = require("./errors");
+const findSlice = (slices) => (sliceId) => (0, function_1.pipe)(slices.find((slice) => slice.id === sliceId), E.fromNullable(errors_1.SharedSliceErrors.SliceTypeNotFound(sliceId)));
+exports.findSlice = findSlice;
+const findSliceVariation = (slice) => (variation) => (0, function_1.pipe)(slice.variations.find((v) => v.id === variation), E.fromNullable(errors_1.SharedSliceErrors.VariationNotFound(variation, slice.id)));
+exports.findSliceVariation = findSliceVariation;

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

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

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

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

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

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

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

@@ -12,4 +12,4 @@ const uidValue = validators_1.String.pipe(new t.Type("ImportUIDField", (u) => va
     }
     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));
+exports.ImportUID = (0, ImportContent_1.ImportContent)("UID", uidValue);

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

@@ -1,27 +1,13 @@
 import * as t from "io-ts";
-declare const EmbedProto: t.ExactC<t.IntersectionC<[t.TypeC<{
+export declare const ImportEmbedValue: t.ExactC<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>;
+    value: {
+        embed_url: string;
+    } | null;
+}, {
+    embed_url: string;
+} | undefined, unknown>;
 export declare type ImportEmbed = t.TypeOf<typeof ImportEmbed>;
-export {};

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

@@ -1,13 +1,9 @@
 "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/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 {
@@ -29,26 +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.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));
+exports.ImportEmbedValue = t.strict({
+    embed_url: EmbedUrl,
+});
+exports.ImportEmbed = (0, ImportContent_1.ImportContent)("Embed", (0, validators_1.EmptyObjectOrElse)(exports.ImportEmbedValue));

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