@prismicio/types-internal 3.17.0-pr.145.680cd65 → 3.17.2

package/lib/customtypes/widgets/slices/Slices.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSlices = exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = exports.SlicesLabels = exports.SlicesFieldType = exports.LegacySlicesFieldType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const common_1 = require("../../../common");
+const validators_1 = require("../../../validators");
+const Group_1 = require("../Group");
+const CompositeSlice_1 = require("./CompositeSlice");
+const LegacySlice_1 = require("./LegacySlice");
+const SharedSlice_1 = require("./SharedSlice");
+const SharedSliceRef_1 = require("./SharedSliceRef");
+exports.LegacySlicesFieldType = "Choice";
+exports.SlicesFieldType = "Slices";
+exports.SlicesLabels = t.union([
+    t.record(t.string, t.readonlyArray(t.exact(t.intersection([
+        t.type({
+            name: t.string,
+        }),
+        t.partial({
+            display: t.string,
+        }),
+    ])))),
+    t.null,
+]);
+function slicesConfigReader(codec) {
+    return t.exact(t.partial({
+        label: validators_1.StringOrNull,
+        labels: exports.SlicesLabels,
+        choices: t.record(common_1.WidgetKey, t.union([LegacySlice_1.LegacySlice, CompositeSlice_1.CompositeSlice, codec])),
+    }));
+}
+exports.slicesConfigReader = slicesConfigReader;
+exports.StaticSlicesConfig = slicesConfigReader(SharedSlice_1.SharedSlice);
+exports.DynamicSlicesConfig = slicesConfigReader(SharedSliceRef_1.SharedSliceRef);
+const SlicesConfig = {
+    toStatic(config, sharedSlices) {
+        const choices = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
+            if (slice.type === "SharedSlice") {
+                const sharedSlice = sharedSlices.get(ref);
+                if (sharedSlice)
+                    return { ...acc, [ref]: sharedSlice };
+                else
+                    return acc;
+            }
+            else {
+                return { ...acc, [ref]: slice };
+            }
+        }, {});
+        return { ...config, choices };
+    },
+};
+function slicesReader(codec) {
+    return t.exact(t.intersection([
+        t.type({
+            type: t.keyof({
+                [exports.SlicesFieldType]: null,
+                [exports.LegacySlicesFieldType]: null,
+            }),
+        }),
+        t.partial({
+            fieldset: validators_1.StringOrNull,
+            config: codec,
+        }),
+    ]));
+}
+exports.slicesReader = slicesReader;
+exports.StaticSlices = slicesReader(exports.StaticSlicesConfig);
+exports.DynamicSlices = slicesReader(exports.DynamicSlicesConfig);
+exports.Slices = {
+    toStatic(slices, sharedSlices) {
+        if (!slices.config)
+            return slices;
+        else {
+            return {
+                ...slices,
+                config: SlicesConfig.toStatic(slices.config, sharedSlices),
+            };
+        }
+    },
+};
+function traverseSlices(args) {
+    var _a;
+    const { path: prevPath, slices, onField } = args;
+    if (!((_a = slices.config) === null || _a === void 0 ? void 0 : _a.choices))
+        return slices;
+    let choices;
+    for (const [key, prevModel] of Object.entries(slices.config.choices)) {
+        const path = [...prevPath, key];
+        let model;
+        switch (prevModel.type) {
+            case "Slice":
+                model = (0, CompositeSlice_1.traverseCompositeSlice)({
+                    path,
+                    slice: prevModel,
+                    onField: onField,
+                });
+                break;
+            case "SharedSlice":
+                if ("variations" in prevModel)
+                    model = (0, SharedSlice_1.traverseSharedSlice)({
+                        path,
+                        slice: prevModel,
+                        onField,
+                    });
+                else
+                    model = prevModel;
+                break;
+            // Group and other fields are technically possible because of legacy slices.
+            case "Group":
+                model = onField({
+                    path,
+                    key,
+                    field: (0, Group_1.traverseNestedGroup)({
+                        path,
+                        group: prevModel,
+                        onField: onField,
+                    }),
+                });
+                break;
+            default:
+                model = onField({
+                    path,
+                    key,
+                    field: prevModel,
+                });
+                break;
+        }
+        if (model !== prevModel) {
+            if (!choices)
+                choices = { ...slices.config.choices };
+            choices[key] = model;
+        }
+    }
+    // returns the traversed model instead of a new one if it didn't change
+    return choices
+        ? {
+            ...slices,
+            config: {
+                ...slices.config,
+                choices,
+            },
+        }
+        : slices;
+}
+exports.traverseSlices = traverseSlices;

package/lib/customtypes/widgets/slices/SlicesTypes.d.ts

@@ -0,0 +1,6 @@
+import * as t from "io-ts";
+export declare const SlicesTypes: t.KeyofC<{
+    Slice: null;
+    SharedSlice: null;
+}>;
+export declare type SlicesTypes = t.TypeOf<typeof SlicesTypes>;

package/lib/customtypes/widgets/slices/SlicesTypes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlicesTypes = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const CompositeSlice_1 = require("./CompositeSlice");
+const SharedSlice_1 = require("./SharedSlice");
+exports.SlicesTypes = t.keyof({
+    [CompositeSlice_1.CompositeSliceType]: null,
+    [SharedSlice_1.SharedSliceType]: null,
+});

package/lib/customtypes/widgets/slices/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./CompositeSlice";
+export * from "./LegacySlice";
+export * from "./SharedSlice";
+export * from "./SharedSliceRef";
+export * from "./Slice";
+export * from "./SlicePrimaryWidget";
+export * from "./Slices";
+export * from "./SlicesTypes";

package/lib/customtypes/widgets/slices/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./CompositeSlice"), exports);
+(0, tslib_1.__exportStar)(require("./LegacySlice"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSlice"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSliceRef"), exports);
+(0, tslib_1.__exportStar)(require("./Slice"), exports);
+(0, tslib_1.__exportStar)(require("./SlicePrimaryWidget"), exports);
+(0, tslib_1.__exportStar)(require("./Slices"), exports);
+(0, tslib_1.__exportStar)(require("./SlicesTypes"), exports);

package/lib/utils/Arrays.d.ts

@@ -0,0 +1 @@
+export declare function toRecord<A extends object>(arr: ReadonlyArray<A>, key: (obj: A) => string): {};

package/lib/utils/Arrays.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRecord = void 0;
+function toRecord(arr, key) {
+    return arr.reduce((acc, entry) => {
+        const k = key(entry);
+        return {
+            ...acc,
+            [k]: entry,
+        };
+    }, {});
+}
+exports.toRecord = toRecord;

package/lib/utils/DocumentId.d.ts

@@ -0,0 +1,2 @@
+import * as t from "io-ts";
+export declare const DocumentId: t.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 tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../validators/function");
+exports.DocumentId = (0, function_1.withCustomError)((0, function_1.refineType)(t.string, "DocumentId", (s) => s.length === 16), () => "DocumentId must be a 16 character string");

package/lib/utils/Fields.d.ts

@@ -0,0 +1,6 @@
+import type { Group, NestableWidget, NestedGroup, UID } from "../customtypes";
+export declare type OnFieldFn<T extends UID | NestableWidget | Group | NestedGroup> = (args: {
+    path: ReadonlyArray<string>;
+    key: string;
+    field: T;
+}) => T;

package/lib/utils/Fields.js

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

package/lib/utils/Objects.d.ts

@@ -0,0 +1,8 @@
+export declare function zipObjects<A, B = A>(objLeft?: Partial<Record<string, A>> | undefined, objRight?: Partial<Record<string, B>> | undefined): Partial<Record<string, {
+    left?: A | undefined;
+    right?: B | undefined;
+}>>;
+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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+function zipObjects(objLeft, objRight) {
+    const allKeys = [
+        ...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {}))),
+    ];
+    return allKeys.reduce((acc, key) => {
+        const left = objLeft === null || objLeft === void 0 ? void 0 : objLeft[key];
+        const right = objRight === null || objRight === void 0 ? void 0 : objRight[key];
+        return {
+            ...acc,
+            [key]: { left, right },
+        };
+    }, {});
+}
+exports.zipObjects = zipObjects;
+function isNotEmpty(obj) {
+    return Boolean(Object.keys(obj).length);
+}
+exports.isNotEmpty = isNotEmpty;
+function withOptionals(object, optionals) {
+    return {
+        ...object,
+        ...optionals.reduce((acc, [key, value]) => {
+            return value ? { ...acc, [key]: value } : acc;
+        }, {}),
+    };
+}
+exports.withOptionals = withOptionals;
+const recordCodec = t.record(t.string, t.unknown);
+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/index.d.ts

@@ -0,0 +1,4 @@
+export * as HexaColorCode from "../common/HexaColorCode";
+export * as Arrays from "./Arrays";
+export * as Fields from "./Fields";
+export * as Objects from "./Objects";

package/lib/utils/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Objects = exports.Fields = exports.Arrays = exports.HexaColorCode = void 0;
+const tslib_1 = require("tslib");
+exports.HexaColorCode = (0, tslib_1.__importStar)(require("../common/HexaColorCode"));
+exports.Arrays = (0, tslib_1.__importStar)(require("./Arrays"));
+exports.Fields = (0, tslib_1.__importStar)(require("./Fields"));
+exports.Objects = (0, tslib_1.__importStar)(require("./Objects"));

package/lib/validators/BasicTypes.d.ts

@@ -0,0 +1,10 @@
+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>;

package/lib/validators/BasicTypes.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 function_2 = require("./function");
+exports.String = (0, function_2.withCustomError)(t.string, () => "The value must be a string");
+exports.StringOrNull = (0, function_2.withCustomError)(t.union([t.string, t.null]), () => "The value must be a string or null");
+exports.Number = (0, function_2.withCustomError)(t.number, () => "The value must be a number");
+exports.NumberOrNull = (0, function_2.withCustomError)(t.union([t.number, t.null]), () => "The value must be a number or null");
+exports.Boolean = (0, function_2.withCustomError)(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());
+    }));
+}, () => []);

package/lib/validators/DateFromString.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.Type<Date, string, unknown>;
+export default _default;

package/lib/validators/DateFromString.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 _1 = require(".");
+exports.default = new t.Type("dateFromString", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(_1.String.validate(u, c), (0, Either_1.chain)((s) => {
+    const d = new Date(s);
+    return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d);
+})), (date) => date.toISOString());

package/lib/validators/DateFromStringOrNumber.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.Type<Date, Date, unknown>;
+export default _default;

package/lib/validators/DateFromStringOrNumber.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+exports.default = new t.Type("dateFromStringOrNumber", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(t.union([t.number, t.string]).validate(u, c), (0, Either_1.chain)((s) => {
+    const d = new Date(s);
+    return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d);
+})), (date) => date);

package/lib/validators/DateFromTsMs.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.Type<Date, number, unknown>;
+export default _default;

package/lib/validators/DateFromTsMs.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+exports.default = new t.Type("dateFromTsMs", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(t.number.validate(u, c), (0, Either_1.chain)((s) => {
+    const d = new Date(s);
+    return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d);
+})), (date) => date.getTime());

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(`DefaultOrElse<${inputValidator.name}, ${codec.name}>`, (u) => null === u || codec.is(u), (u, c) => {
+        if ((0, Either_1.isRight)(inputValidator.validate(u, c)))
+            return t.success(null);
+        return codec.validate(u, c);
+    }, (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/IntFromNumber.d.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare type IntFromNumberC = t.Type<t.Int, number, unknown>;
+declare const _default: t.Type<t.Int, number, unknown>;
+/** A codec that succeeds if a number can be parsed to an integer */
+export default _default;

package/lib/validators/IntFromNumber.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+/** A codec that succeeds if a number can be parsed to an integer */
+exports.default = new t.Type("IntFromNumber", t.Int.is, (u, c) => (0, function_1.pipe)(t.number.validate(u, c), (0, Either_1.chain)((n) => {
+    if (t.Int.is(n))
+        return t.success(n);
+    else {
+        return t.success(Math.round(n));
+    }
+})), t.Int.encode);

package/lib/validators/IntFromPixels.d.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+export declare type IntFromPixelsC = t.Type<t.Int, string, unknown>;
+declare const _default: t.Type<t.Int, string, unknown>;
+/**
+ * A codec that succeeds if a string representing pixels (eg: "200px") can be
+ * parsed to an integer
+ */
+export default _default;

package/lib/validators/IntFromPixels.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 PixelsRegex = /^([0-9]+)px$/;
+/**
+ * A codec that succeeds if a string representing pixels (eg: "200px") can be
+ * parsed to an integer
+ */
+exports.default = new t.Type("IntFromPixels", t.Int.is, (u, c) => (0, function_1.pipe)(t.string.validate(u, c), (0, Either_1.chain)((strPixels) => {
+    try {
+        const matched = strPixels.match(PixelsRegex);
+        if (!matched)
+            return t.failure(u, c);
+        /* eslint-disable  @typescript-eslint/no-non-null-assertion */
+        const parsed = parseInt(matched[1]);
+        return t.success(parsed);
+    }
+    catch {
+        return t.failure(u, c);
+    }
+})), String);

package/lib/validators/NonEmptyString.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.Type<string, string, unknown>;
+export default _default;

package/lib/validators/NonEmptyString.js

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

package/lib/validators/NonEmptyStringOrNull.d.ts

@@ -0,0 +1,3 @@
+import { Type } from "io-ts";
+declare const _default: Type<string | null, string | null, unknown>;
+export default _default;

package/lib/validators/NonEmptyStringOrNull.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const io_ts_1 = require("io-ts");
+const StringOrNull_1 = (0, tslib_1.__importDefault)(require("./StringOrNull"));
+exports.default = new io_ts_1.Type("nonEmptyStringOrNull", (u) => typeof u === "string" || u === null, (u, c) => (0, function_1.pipe)(StringOrNull_1.default.validate(u, c), (0, Either_1.chain)((s) => {
+    if (typeof s === "string" && s.length > 0) {
+        return (0, io_ts_1.success)(s);
+    }
+    else {
+        return (0, io_ts_1.success)(null);
+    }
+})), (s) => s);

package/lib/validators/NumberOrNull.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+export default _default;

package/lib/validators/NumberOrNull.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("./function");
+exports.default = (0, function_1.nullable)(t.number);

package/lib/validators/NumberRange.d.ts

@@ -0,0 +1,32 @@
+import * as t from "io-ts";
+declare const _default: (min: number, max: number, fieldName: string) => t.Type<number, number, unknown>;
+/**
+ * Creates a custom runtime type for validating that a number falls within a specified range.
+ *
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @param fieldName - The name of the field being validated (used in error messages).
+ * @returns A runtime type representing the number range validation.
+ *
+ *  * @example
+ * // Creating a custom runtime type for age validation
+ * const AgeType = numberInRange(18, 99, 'Age');
+ *
+ * // Valid age
+ * const validAgeResult = AgeType.decode(25);
+ * if (t.isRight(validAgeResult)) {
+ *   console.log('Valid age:', validAgeResult.right); // Output: Valid age: 25
+ * } else {
+ *   console.error('Invalid age:', t.left(validAgeResult).map(t.reporter.report));
+ * }
+ *
+ * @example
+ * // Invalid age
+ * const invalidAgeResult = AgeType.decode(15);
+ * if (t.isRight(invalidAgeResult)) {
+ *   console.log('Valid age:', invalidAgeResult.right);
+ * } else {
+ *   console.error('Invalid age:', t.left(invalidAgeResult).map(t.reporter.report));
+ * }
+ */
+export default _default;

package/lib/validators/NumberRange.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const BasicTypes_1 = require("./BasicTypes");
+/**
+ * Creates a custom runtime type for validating that a number falls within a specified range.
+ *
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @param fieldName - The name of the field being validated (used in error messages).
+ * @returns A runtime type representing the number range validation.
+ *
+ *  * @example
+ * // Creating a custom runtime type for age validation
+ * const AgeType = numberInRange(18, 99, 'Age');
+ *
+ * // Valid age
+ * const validAgeResult = AgeType.decode(25);
+ * if (t.isRight(validAgeResult)) {
+ *   console.log('Valid age:', validAgeResult.right); // Output: Valid age: 25
+ * } else {
+ *   console.error('Invalid age:', t.left(validAgeResult).map(t.reporter.report));
+ * }
+ *
+ * @example
+ * // Invalid age
+ * const invalidAgeResult = AgeType.decode(15);
+ * if (t.isRight(invalidAgeResult)) {
+ *   console.log('Valid age:', invalidAgeResult.right);
+ * } else {
+ *   console.error('Invalid age:', t.left(invalidAgeResult).map(t.reporter.report));
+ * }
+ */
+exports.default = (min, max, fieldName) => BasicTypes_1.Number.pipe(new t.Type("numberInRange", (u) => BasicTypes_1.Number.is(u), (u, context) => {
+    if (u > max || u < min) {
+        return t.failure(u, context, `${fieldName} must be a number between ${min} and ${max}`);
+    }
+    return t.success(u);
+}, t.identity));

package/lib/validators/StringFromBoolean.d.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare type StringFromBooleanC = t.Type<string, string, unknown>;
+declare const _default: t.Type<string, string, unknown>;
+/** A codec that validates a Boolean and convert it as a string */
+export default _default;

package/lib/validators/StringFromBoolean.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+/** A codec that validates a Boolean and convert it as a string */
+exports.default = new t.Type("StringFromInt", t.string.is, (u, c) => (0, function_1.pipe)(t.boolean.validate(u, c), (0, Either_1.chain)((i) => {
+    return t.success(i.toString());
+})), (i) => i);

package/lib/validators/StringFromNumber.d.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare type StringFromNumberC = t.Type<string, string, unknown>;
+declare const _default: t.Type<string, string, unknown>;
+/** A codec that validates a number and convert it as a string */
+export default _default;

package/lib/validators/StringFromNumber.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+/** A codec that validates a number and convert it as a string */
+exports.default = new t.Type("StringFromInt", t.string.is, (u, c) => (0, function_1.pipe)(t.number.validate(u, c), (0, Either_1.chain)((i) => {
+    return t.success(i.toString());
+})), (i) => i);

package/lib/validators/StringOrNull.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+export default _default;