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

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

@@ -0,0 +1,38 @@
+import type { TypeOf } from "io-ts";
+import * as t from "io-ts";
+declare const WebLink: t.IntersectionC<[t.TypeC<{
+    link_type: t.LiteralC<"Web">;
+    url: t.StringC;
+}>, t.PartialC<{
+    target: t.StringC;
+}>]>;
+export declare type WebLink = t.TypeOf<typeof WebLink>;
+declare const DocumentLink: t.TypeC<{
+    link_type: t.LiteralC<"Document">;
+    id: t.Type<string, string, unknown>;
+}>;
+export declare type DocumentLink = t.TypeOf<typeof DocumentLink>;
+declare const MediaLink: t.TypeC<{
+    link_type: t.LiteralC<"Media">;
+    id: t.StringC;
+}>;
+export declare type MediaLink = t.TypeOf<typeof MediaLink>;
+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>;
+export {};

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

@@ -0,0 +1,35 @@
+"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 io_ts_types_1 = require("io-ts-types");
+const DocumentId_1 = require("../../../../utils/DocumentId");
+const validators_1 = require("../../../../validators");
+const ImportContent_1 = require("../ImportContent");
+const LinkTypeValidator = 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 `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: DocumentId_1.DocumentId,
+});
+const MediaLink = t.type({
+    link_type: t.literal("Media"),
+    id: validators_1.String,
+});
+const Link = LinkTypeValidator.pipe(t.union([WebLink, DocumentLink, MediaLink]));
+// This is the default value for the link
+const AnyLink = t.type({
+    link_type: t.literal("Any"),
+});
+exports.ImportLink = (0, ImportContent_1.ImportContent)("Link", (0, validators_1.DefaultOrElse)(AnyLink)(Link));

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

@@ -1,9 +1,125 @@
 import type { NestableWidget } from "../../../../customtypes";
-import { ImportDate, ImportTimestamp } from ".";
+import { ImportBoolean } from "./Boolean";
 import { ImportColor } from "./Color";
+import { ImportDate } from "./Date";
+import { ImportEmbed } from "./Embed";
+import { ImportGeoPoint } from "./GeoPoint";
+import { ImportImage } from "./Image";
+import { ImportLink } from "./Link";
 import { ImportNumber } from "./Number";
 import { ImportSelect } from "./Select";
 import { ImportText } from "./Text";
-export declare type ImportNestable = ImportColor | ImportSelect | ImportNumber | ImportText | ImportDate | ImportTimestamp;
-export declare const isNestableFieldValue: (u: unknown) => u is ImportNestable;
-export declare function getNestableFieldCodec(field: NestableWidget): import("io-ts").Type<ImportColor, ImportColor, unknown> | import("io-ts").Type<ImportDate, ImportDate, unknown> | import("io-ts").Type<ImportNumber, ImportNumber, unknown> | import("io-ts").Type<ImportSelect, ImportSelect, unknown> | import("io-ts").Type<ImportText, ImportText, unknown> | import("io-ts").Type<ImportTimestamp, ImportTimestamp, unknown>;
+import { ImportTimestamp } from "./Timestamp";
+export declare type ImportNestable = ImportBoolean | ImportColor | ImportNumber | ImportSelect | ImportText | ImportDate | ImportTimestamp | ImportEmbed | ImportLink | ImportGeoPoint | ImportImage;
+export declare const ImportNestable: {
+    is(u: unknown): u is ImportNestable;
+    decode: (field: NestableWidget) => (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("./Image").ImageFieldWithThumbnails | null;
+        }, import("./Image").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("./Image").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;
+        }>;
+    };
+};

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

@@ -1,34 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNestableFieldCodec = exports.isNestableFieldValue = void 0;
-const _1 = require(".");
+exports.ImportNestable = void 0;
+const Boolean_1 = require("./Boolean");
 const Color_1 = require("./Color");
+const Date_1 = require("./Date");
+const Embed_1 = require("./Embed");
+const GeoPoint_1 = require("./GeoPoint");
+const Image_1 = require("./Image");
+const Link_1 = require("./Link");
 const Number_1 = require("./Number");
 const Select_1 = require("./Select");
 const Text_1 = require("./Text");
-const isNestableFieldValue = (u) => Color_1.ImportColor.is(u) ||
-    (0, Select_1.ImportSelect)().is(u) ||
-    (0, Number_1.ImportNumber)().is(u) ||
-    Text_1.ImportText.is(u) ||
-    _1.ImportDate.is(u) ||
-    _1.ImportTimestamp.is(u);
-exports.isNestableFieldValue = isNestableFieldValue;
-function getNestableFieldCodec(field) {
-    switch (field.type) {
-        case "Color":
-            return Color_1.ImportColor;
-        case "Select":
-            return (0, Select_1.ImportSelect)(field.config);
-        case "Number":
-            return (0, Number_1.ImportNumber)(field.config);
-        case "Text":
-            return Text_1.ImportText;
-        case "Date":
-            return _1.ImportDate;
-        case "Timestamp":
-            return _1.ImportTimestamp;
-        default:
-            throw new Error(`Unsupported type of nestable field ${field.type}`);
-    }
-}
-exports.getNestableFieldCodec = getNestableFieldCodec;
+const Timestamp_1 = require("./Timestamp");
+exports.ImportNestable = {
+    is(u) {
+        return (Boolean_1.ImportBoolean.is(u) ||
+            Color_1.ImportColor.is(u) ||
+            (0, Number_1.ImportNumber)().is(u) ||
+            (0, Select_1.ImportSelect)().is(u) ||
+            Text_1.ImportText.is(u) ||
+            Date_1.ImportDate.is(u) ||
+            Timestamp_1.ImportTimestamp.is(u) ||
+            Embed_1.ImportEmbed.is(u) ||
+            Link_1.ImportLink.is(u) ||
+            GeoPoint_1.ImportGeoPoint.is(u) ||
+            (0, Image_1.ImportImage)().is(u));
+    },
+    decode: (field) => {
+        return (content) => {
+            const codec = (() => {
+                switch (field.type) {
+                    case "Boolean":
+                        return Boolean_1.ImportBoolean;
+                    case "Color":
+                        return Color_1.ImportColor;
+                    case "Number":
+                        return (0, Number_1.ImportNumber)(field);
+                    case "Select":
+                        return (0, Select_1.ImportSelect)(field);
+                    case "Text":
+                        return Text_1.ImportText;
+                    case "Date":
+                        return Date_1.ImportDate;
+                    case "Timestamp":
+                        return Timestamp_1.ImportTimestamp;
+                    case "Embed":
+                        return Embed_1.ImportEmbed;
+                    case "Link":
+                        return Link_1.ImportLink;
+                    case "Image":
+                        return (0, Image_1.ImportImage)(field);
+                    case "GeoPoint":
+                        return GeoPoint_1.ImportGeoPoint;
+                    default:
+                        throw new Error(`Unsupported type of nestable field ${field.type}`);
+                }
+            })();
+            return {
+                codec,
+                result: codec.decode(content),
+            };
+        };
+    },
+};

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

@@ -1,10 +1,17 @@
 import * as t from "io-ts";
-import type { ImportFieldOutput } from "..";
-export declare type ImportNumber = ImportFieldOutput<"Number", number>;
-export declare const ImportNumber: (config?: {
-    label?: string | null | undefined;
-    placeholder?: string;
-    min?: number;
-    max?: number;
-    step?: number;
-} | undefined) => t.Type<ImportNumber, ImportNumber, unknown>;
+export declare const ImportNumber: (field?: ({
+    type: "Number";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        placeholder?: string;
+        min?: number;
+        max?: number;
+        step?: number;
+    };
+}) | undefined) => t.Type<{
+    type: "Number";
+    value: number | null;
+}, number | undefined, unknown>;
+export declare type ImportNumber = t.TypeOf<ReturnType<typeof ImportNumber>>;

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

@@ -4,13 +4,14 @@ exports.ImportNumber = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const validators_1 = require("../../../../validators");
-const ImportNumber = (config) => (0, validators_1.NullOrT)(validators_1.Number.pipe(new t.Type("ImportColorField", (u) => validators_1.Number.is(u), (n, c) => {
+const ImportContent_1 = require("../ImportContent");
+const numberValue = (config) => validators_1.Number.pipe(new t.Type("ImportNumberValue", (u) => validators_1.Number.is(u), (n, c) => {
     const min = config === null || config === void 0 ? void 0 : config.min;
     const max = config === null || config === void 0 ? void 0 : config.max;
-    if ((min !== undefined && n < min) ||
-        (max !== undefined && n > max)) {
+    if ((min !== undefined && n < min) || (max !== undefined && n > max)) {
         return t.failure(n, c, `The value must be between [${min !== undefined ? min : ""}, ${max !== undefined ? max : ""}]`);
     }
     return t.success(n);
-}, t.identity)))((n) => ({ type: "Number", value: n }));
+}, t.identity));
+const ImportNumber = (field) => (0, ImportContent_1.ImportContent)("Number", (0, validators_1.NullOrElse)(numberValue(field === null || field === void 0 ? void 0 : field.config)));
 exports.ImportNumber = ImportNumber;

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

@@ -1,9 +1,16 @@
 import * as t from "io-ts";
-import type { ImportFieldOutput } from "..";
-export declare type ImportSelect = ImportFieldOutput<"Select", string>;
-export declare const ImportSelect: (config?: {
-    label?: string | null | undefined;
-    placeholder?: string;
-    default_value?: string;
-    options?: readonly string[];
-} | undefined) => t.Type<ImportSelect, ImportSelect, unknown>;
+export declare const ImportSelect: (field?: ({
+    type: "Select";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        placeholder?: string;
+        default_value?: string;
+        options?: readonly string[];
+    };
+}) | undefined) => t.Type<{
+    type: "Select";
+    value: string | null;
+}, string | undefined, unknown>;
+export declare type ImportSelect = t.TypeOf<ReturnType<typeof ImportSelect>>;

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

@@ -4,7 +4,8 @@ exports.ImportSelect = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const validators_1 = require("../../../../validators");
-const ImportSelect = (config) => (0, validators_1.NullOrT)(validators_1.String.pipe(new t.Type("ImportColorField", (u) => validators_1.String.is(u), (s, c) => {
+const ImportContent_1 = require("../ImportContent");
+const selectValue = (config) => validators_1.String.pipe(new t.Type("ImportSelectValue", (u) => validators_1.String.is(u), (s, c) => {
     var _a;
     if (!(config === null || config === void 0 ? void 0 : config.options)) {
         return t.failure(s, c, "The value must be defined in the custom type's configuration of the field");
@@ -13,5 +14,6 @@ const ImportSelect = (config) => (0, validators_1.NullOrT)(validators_1.String.p
         return t.failure(s, c, `The value must be one of these: ${(_a = config.options) === null || _a === void 0 ? void 0 : _a.join(",")}`);
     }
     return t.success(s);
-}, t.identity)))((s) => ({ type: "Select", value: s }));
+}, t.identity));
+const ImportSelect = (field) => (0, ImportContent_1.ImportContent)("Select", (0, validators_1.NullOrElse)(selectValue(field === null || field === void 0 ? void 0 : field.config)));
 exports.ImportSelect = ImportSelect;

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

@@ -1,3 +1,6 @@
-import type { ImportFieldOutput } from "..";
-export declare type ImportText = ImportFieldOutput<"Text", string>;
-export declare const ImportText: import("io-ts").Type<ImportText, ImportText, unknown>;
+import type { TypeOf } from "io-ts";
+export declare const ImportText: import("io-ts").Type<{
+    type: "Text";
+    value: string | null;
+}, string | undefined, unknown>;
+export declare type ImportText = TypeOf<typeof ImportText>;

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

@@ -2,4 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportText = void 0;
 const validators_1 = require("../../../../validators");
-exports.ImportText = (0, validators_1.NullOrT)(validators_1.String)((s) => ({ type: "Text", value: s }));
+const ImportContent_1 = require("../ImportContent");
+exports.ImportText = (0, ImportContent_1.ImportContent)("Text", (0, validators_1.NullOrElse)(validators_1.String));

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

@@ -1,5 +1,7 @@
 import * as t from "io-ts";
-import type { ImportFieldOutput } from "..";
 export declare const TIMESTAMP_INPUT_REGEX: RegExp;
-export declare type ImportTimestamp = ImportFieldOutput<"Timestamp", Date>;
-export declare const ImportTimestamp: t.Type<ImportTimestamp, ImportTimestamp, unknown>;
+export declare const ImportTimestamp: t.Type<{
+    type: "Timestamp";
+    value: Date | null;
+}, Date | undefined, unknown>;
+export declare type ImportTimestamp = t.TypeOf<typeof ImportTimestamp>;

package/lib/import/validators/fields/nestable/Timestamp.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");
 exports.TIMESTAMP_INPUT_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:(?:[+-]{1}\d{2}:?\d{2})|Z)$/;
-exports.ImportTimestamp = (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 timestampValue = new t.Type("ImportTimestampValue", (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 || !exports.TIMESTAMP_INPUT_REGEX.test(s)) {
         return t.failure(u, c, "The value must be a DateTime in the format YYYY-MM-DDTHH:MM:SS+0000");
     }
     return t.success(date);
-})), t.identity))((s) => ({ type: "Timestamp", value: s }));
+})), t.identity);
+exports.ImportTimestamp = (0, ImportContent_1.ImportContent)("Timestamp", (0, validators_1.NullOrElse)(timestampValue));

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

@@ -1,5 +1,11 @@
+export * from "./Boolean";
 export * from "./Color";
 export * from "./Date";
+export * from "./Embed";
+export * from "./GeoPoint";
+export * from "./Image";
+export * from "./Image/index";
+export * from "./Link";
 export * from "./Nestable";
 export * from "./Number";
 export * from "./Select";

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

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./Boolean"), exports);
 (0, tslib_1.__exportStar)(require("./Color"), exports);
 (0, tslib_1.__exportStar)(require("./Date"), exports);
+(0, tslib_1.__exportStar)(require("./Embed"), exports);
+(0, tslib_1.__exportStar)(require("./GeoPoint"), exports);
+(0, tslib_1.__exportStar)(require("./Image"), exports);
+(0, tslib_1.__exportStar)(require("./Image/index"), exports);
+(0, tslib_1.__exportStar)(require("./Link"), exports);
 (0, tslib_1.__exportStar)(require("./Nestable"), exports);
 (0, tslib_1.__exportStar)(require("./Number"), exports);
 (0, tslib_1.__exportStar)(require("./Select"), exports);

package/lib/utils/DocumentId.d.ts

@@ -0,0 +1 @@
+export declare const DocumentId: import("io-ts").Type<string, string, unknown>;

package/lib/utils/DocumentId.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentId = void 0;
+const io_ts_types_1 = require("io-ts-types");
+const validators_1 = require("../validators");
+const function_1 = require("../validators/function");
+exports.DocumentId = (0, io_ts_types_1.withMessage)((0, function_1.refineType)(validators_1.String, "DocumentId", (s) => s.length === 16), () => "DocumentId must be a 16 character string");

package/lib/utils/Objects.d.ts

@@ -5,3 +5,4 @@ export declare function zipObjects<A, B = A>(objLeft?: Partial<Record<string, A>
 export declare function isNotEmpty<A extends object>(obj: A): boolean;
 export declare function withOptionals<T extends object>(object: T, optionals: Array<[keyof T, T[keyof T] | null | undefined]>): T;
 export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function mapValues<T, O>(record: Record<string, T>, fn: (value: T, key: string) => O): Record<string, O>;

package/lib/utils/Objects.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObject = exports.withOptionals = exports.isNotEmpty = exports.zipObjects = void 0;
+exports.mapValues = exports.isObject = exports.withOptionals = exports.isNotEmpty = exports.zipObjects = void 0;
 const tslib_1 = require("tslib");
 const Either_1 = require("fp-ts/lib/Either");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
@@ -36,3 +36,7 @@ function isObject(value) {
     return (0, Either_1.isRight)(recordCodec.decode(value));
 }
 exports.isObject = isObject;
+function mapValues(record, fn) {
+    return Object.entries(record).reduce((acc, [key, value]) => ({ ...acc, [key]: fn(value, key) }), {});
+}
+exports.mapValues = mapValues;

package/lib/utils/io-ts.d.ts

@@ -0,0 +1,2 @@
+import type { Validation } from "io-ts";
+export declare const combineValidationResults: <T>(validationResults: readonly Validation<T>[]) => Validation<readonly T[]>;

package/lib/utils/io-ts.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineValidationResults = 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 RA = (0, tslib_1.__importStar)(require("fp-ts/ReadonlyArray"));
+/*
+ * Semigroup simply defines how to concatenate two values of the same type.
+ * In this instance, Errors from io-ts are arrays already, so we just need to concatenate them.
+ */
+const validationErrorsSemigroup = {
+    concat: (a, b) => [...a, ...b],
+};
+/*
+ * This is a helper function to combine multiple io-ts validations into one.
+ *  t.array(...) works in the same way - it collects all the errors when decoding an array of values.
+ * 	However, it requires you to pass in a single io-ts validator as a parameter, which is not always convenient.
+ * 	Sometimes we have arrays of validation results received from function calls that don't have a validator instance.
+ */
+const combineValidationResults = (validationResults) => (0, function_1.pipe)(validationResults, RA.traverse(E.getApplicativeValidation(validationErrorsSemigroup))((validation) => validation));
+exports.combineValidationResults = combineValidationResults;

package/lib/validators/BasicTypes.d.ts

@@ -1,3 +1,12 @@
 import * as t from "io-ts";
 export declare const String: t.StringC;
+export declare const StringOrNull: t.UnionC<[t.StringC, t.NullC]>;
 export declare const Number: t.NumberC;
+export declare const NumberOrNull: t.UnionC<[t.NumberC, t.NullC]>;
+export declare const Boolean: t.BooleanC;
+export declare const EmptyObject: t.Type<Record<never, never>, {
+    [key: string]: unknown;
+}, unknown>;
+export declare const EmptyArray: t.Type<never[], never[], unknown>;
+export declare const AnyObject: t.RecordC<t.StringC, t.UnknownC>;
+export declare const AnyArray: t.ArrayC<t.UnknownC>;

package/lib/validators/BasicTypes.js

@@ -1,8 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Number = exports.String = void 0;
+exports.AnyArray = exports.AnyObject = exports.EmptyArray = exports.EmptyObject = exports.Boolean = exports.NumberOrNull = exports.Number = exports.StringOrNull = exports.String = 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 io_ts_types_1 = require("io-ts-types");
 exports.String = (0, io_ts_types_1.withMessage)(t.string, () => "The value must be a string");
+exports.StringOrNull = (0, io_ts_types_1.withMessage)(t.union([t.string, t.null]), () => "The value must be a string or null");
 exports.Number = (0, io_ts_types_1.withMessage)(t.number, () => "The value must be a number");
+exports.NumberOrNull = (0, io_ts_types_1.withMessage)(t.union([t.number, t.null]), () => "The value must be a number or null");
+exports.Boolean = (0, io_ts_types_1.withMessage)(t.boolean, () => "The value must be a boolean");
+exports.EmptyObject = t.UnknownRecord.pipe(new t.Type("emptyObject", (u) => t.UnknownRecord.is(u), (u, c) => {
+    if (Object.keys(u).length > 0)
+        return t.failure(u, c, "The object is not empty.");
+    return t.success({});
+}, t.identity));
+exports.EmptyArray = new t.Type("emptyArray", (u) => t.UnknownArray.is(u) && u.length === 0, (u, c) => {
+    return (0, function_1.pipe)(t.UnknownArray.decode(u), fp_ts_1.either.chain((parsedArray) => {
+        if (parsedArray.length > 0)
+            return t.failure(u, c, "The array is not empty.");
+        return t.success(new Array());
+    }));
+}, () => []);
+exports.AnyObject = (0, io_ts_types_1.withMessage)(t.record(t.string, t.unknown), () => "The value must be an object");
+exports.AnyArray = (0, io_ts_types_1.withMessage)(t.array(t.unknown), () => "The value must be an array");

package/lib/validators/DefaultOrElse.d.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare const DefaultOrElse: <I, A, O = A>(inputValidator: t.Type<I, I, unknown>) => (codec: t.Type<A, O, unknown>) => t.Type<A | null, O | undefined, unknown>;
+export declare const NullOrElse: <A, O = A>(codec: t.Type<A, O, unknown>) => t.Type<A | null, O | undefined, unknown>;
+export declare const EmptyObjectOrElse: <A, O = A>(codec: t.Type<A, O, unknown>) => t.Type<A | null, O | undefined, unknown>;
+export declare const EmptyArrayOrElse: <A, O = A>(codec: t.Type<A, O, unknown>) => t.Type<A | null, O | undefined, unknown>;

package/lib/validators/DefaultOrElse.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyArrayOrElse = exports.EmptyObjectOrElse = exports.NullOrElse = exports.DefaultOrElse = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/lib/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const BasicTypes_1 = require("./BasicTypes");
+const DefaultOrElse = (inputValidator) => {
+    return (codec) => new t.Type("NullOrT", (u) => null === u || codec.is(u), (u) => {
+        if ((0, Either_1.isRight)(inputValidator.decode(u)))
+            return t.success(null);
+        return codec.decode(u);
+    }, (chunk) => (chunk ? codec.encode(chunk) : undefined));
+};
+exports.DefaultOrElse = DefaultOrElse;
+const NullOrElse = (codec) => (0, exports.DefaultOrElse)(t.null)(codec);
+exports.NullOrElse = NullOrElse;
+const EmptyObjectOrElse = (codec) => (0, exports.DefaultOrElse)(BasicTypes_1.EmptyObject)(codec);
+exports.EmptyObjectOrElse = EmptyObjectOrElse;
+const EmptyArrayOrElse = (codec) => (0, exports.DefaultOrElse)(BasicTypes_1.EmptyArray)(codec);
+exports.EmptyArrayOrElse = EmptyArrayOrElse;

package/lib/validators/NonEmptyString.js

@@ -2,5 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
 const function_1 = require("./function");
-exports.default = (0, function_1.refineType)(t.string, "nonEmptyString", (s) => s.trim().length > 0);
+exports.default = (0, io_ts_types_1.withMessage)((0, function_1.refineType)(t.string, "nonEmptyString", (s) => s.trim().length > 0), () => "The value must be a non-empty string");