@infra-blocks/zod-utils 0.23.1 → 0.24.0-alpha.0

package/README.md

@@ -25,11 +25,12 @@ compiles and runs successfully.
 - [aws](#aws)
 - [codec](#codec)
 - [geojson](#geojson)
+- [inferBrand](#inferbrand)
 - [iso](#iso)
 - [json](#json)
 - [number](#number)
 - [string](#string)
-- [typeGuard](#type-guard)
+- [typeGuard](#typeguard)
 - [isValid](#is-valid)
 
 ### aws
@@ -274,6 +275,20 @@ zu.geojson().parse({
 });
 ```
 
+### inferBrand
+
+The `zu.inferBrand<T>` type utility extracts the brand(s) from a given type. It resolves to `never` if the
+type is not branded. It unionizes the brands if more than one exists.
+
+```typescript
+import { z } from "zod";
+import { zu } from "@infra-blocks/zod-utils";
+
+type Never = zu.inferBrand<string>; // Resolves to never.
+type StringBrand = zu.inferBrand<number & z.$brand<"Toto">>; // Resolves to "Toto".
+type UnionBrands = zu.inferBrand<number & z.$brand<"Toto"> & z.$brand<5>>; // Resolves to "Toto" | 5.
+```
+
 ### iso
 
 The `iso` module is an extension of `zod`'s own `iso` module. All schemas return [branded types](#branded-types).
@@ -408,7 +423,7 @@ expectTypeOf(result).toEqualTypeOf<NumberString>();
 expect(result).to.equal("1234.5678");
 ```
 
-### Type Guard
+### typeGuard
 
 The `typeGuard` utility allows to obtain a function that will act as a type guard for the type
 that the wrapped schema outputs. It is most useful with branded types, where the information

package/lib/cjs/index.d.ts

@@ -1,77 +1,2 @@
-import type { TypeGuard } from "@infra-blocks/types";
-import type { z } from "zod";
-import { isValid } from "./is-valid.js";
-/**
- * Returns a type guard function using the provided schema as the source of truth.
- *
- * It uses the `validate` function internally.
- *
- * @param schema - The schema used to verify the inputs will be of the correct type.
- *
- * @returns A type guard function that uses the provided schema to asserts whether the
- * input is of the proper type or not.
- *
- * @note Type guards work best with branded types. Given two schemas, z.string().min(5),
- * and z.string().min(5).brand("Min5String"), the former type guard would only assert
- * that the input is string (even if the length check is also done), whereas in the
- * former case, that information is also carried with the type.
- */
-declare function typeGuard<S extends z.ZodType>(schema: S): TypeGuard<z.infer<S>>;
-declare const zu: {
-    aws: {
-        accountId: typeof import("./aws/account-id.js").accountId;
-        arn: typeof import("./aws/arn.js").arn;
-        region: typeof import("./aws/region.js").region;
-        partition: typeof import("./aws/partition.js").partition;
-    };
-    codec: {
-        csv: () => z.ZodCodec<z.ZodString, z.ZodArray<z.ZodString>>;
-        jsonParse: <S extends z.ZodType>(schema: S) => z.ZodCodec<z.core.$ZodBranded<z.ZodString, "JsonString">, S>;
-        ms: (options?: {
-            long: boolean;
-        }) => z.ZodCodec<z.ZodString, z.ZodNumber>;
-        stringtoInteger: () => z.ZodCodec<z.core.$ZodBranded<z.ZodString, "IntegerString">, z.core.$ZodBranded<z.ZodInt, "Integer">>;
-        stringToJson: () => z.ZodCodec<z.core.$ZodBranded<z.ZodString, "JsonString">, z.ZodType<import("./json/json.js").Json, unknown, z.core.$ZodTypeInternals<import("./json/json.js").Json, unknown>>>;
-        stringToUrl: () => z.ZodCodec<z.core.$ZodBranded<z.ZodURL, "UrlString">, z.ZodCustom<import("url").URL, import("url").URL>>;
-    };
-    geojson: typeof import("./geojson/geojson.js").geojson & {
-        boundingBox: typeof import("./geojson/bounding-box.js").boundingBox;
-        feature: typeof import("./geojson/feature.js").feature;
-        featureCollection: typeof import("./geojson/feature-collection.js").featureCollection;
-        geometryCollection: typeof import("./geojson/geometry.js").geometryCollection;
-        lineString: typeof import("./geojson/line-string.js").lineString;
-        multiLineString: typeof import("./geojson/multi-line-string.js").multiLineString;
-        multiPoint: typeof import("./geojson/multi-point.js").multiPoint;
-        multiPolygon: typeof import("./geojson/multi-polygon.js").multiPolygon;
-        point: typeof import("./geojson/point.js").point;
-        polygon: typeof import("./geojson/polygon.js").polygon;
-        coordinate: typeof import("./geojson/coordinate.js").coordinate;
-    };
-    iso: {
-        currencyCode: () => z.core.$ZodBranded<z.ZodEnum<{
-            [x: string]: string;
-        }>, "IsoCurrencyCode">;
-        countryCode: {
-            alpha3: () => z.core.$ZodBranded<z.ZodEnum<{
-                [x: string]: string;
-            }>, "IsoAlpha3CountryCode">;
-        };
-    };
-    json: (() => z.ZodType<import("./json/json.js").Json, unknown, z.core.$ZodTypeInternals<import("./json/json.js").Json, unknown>>) & {
-        array: () => z.ZodArray<z.ZodType<import("./json/json.js").Json, unknown, z.core.$ZodTypeInternals<import("./json/json.js").Json, unknown>>>;
-        object: () => z.ZodRecord<z.ZodString, z.ZodType<import("./json/json.js").Json, unknown, z.core.$ZodTypeInternals<import("./json/json.js").Json, unknown>>>;
-        primitive: () => z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
-    };
-    number: {
-        integer: () => z.core.$ZodBranded<z.ZodInt, "Integer">;
-    };
-    string: {
-        integer: () => z.core.$ZodBranded<z.ZodString, "IntegerString">;
-        json: () => z.core.$ZodBranded<z.ZodString, "JsonString">;
-        number: () => z.core.$ZodBranded<z.ZodString, "NumberString">;
-        url: () => z.core.$ZodBranded<z.ZodURL, "UrlString">;
-    };
-    isValid: typeof isValid;
-    typeGuard: typeof typeGuard;
-};
+import * as zu from "./zu.js";
 export { zu };

package/lib/cjs/index.js

@@ -1,44 +1,39 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zu = void 0;
-const index_js_1 = require("./aws/index.js");
-const index_js_2 = require("./codec/index.js");
-const index_js_3 = require("./geojson/index.js");
-const is_valid_js_1 = require("./is-valid.js");
-const index_js_4 = require("./iso/index.js");
-const index_js_5 = require("./json/index.js");
-const index_js_6 = require("./number/index.js");
-const index_js_7 = require("./string/index.js");
-/**
- * Returns a type guard function using the provided schema as the source of truth.
- *
- * It uses the `validate` function internally.
- *
- * @param schema - The schema used to verify the inputs will be of the correct type.
- *
- * @returns A type guard function that uses the provided schema to asserts whether the
- * input is of the proper type or not.
- *
- * @note Type guards work best with branded types. Given two schemas, z.string().min(5),
- * and z.string().min(5).brand("Min5String"), the former type guard would only assert
- * that the input is string (even if the length check is also done), whereas in the
- * former case, that information is also carried with the type.
- */
-function typeGuard(schema) {
-    return (value) => {
-        return (0, is_valid_js_1.isValid)(schema, value);
-    };
-}
-const zu = {
-    aws: index_js_1.aws,
-    codec: index_js_2.codec,
-    geojson: index_js_3.geojson,
-    iso: index_js_4.iso,
-    json: index_js_5.json,
-    number: index_js_6.number,
-    string: index_js_7.string,
-    isValid: is_valid_js_1.isValid,
-    typeGuard,
-};
+const zu = __importStar(require("./zu.js"));
 exports.zu = zu;
 //# sourceMappingURL=index.js.map

package/lib/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAEA,6CAAqC;AACrC,+CAAyC;AACzC,iDAA6C;AAC7C,+CAAwC;AACxC,6CAAqC;AACrC,8CAAuC;AACvC,gDAA2C;AAC3C,gDAA2C;AAE3C;;;;;;;;;;;;;;GAcG;AACH,SAAS,SAAS,CAAsB,MAAS;IAC/C,OAAO,CAAC,KAAc,EAAuB,EAAE;QAC7C,OAAO,IAAA,qBAAO,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAChC,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,EAAE,GAAG;IACT,GAAG,EAAH,cAAG;IACH,KAAK,EAAL,gBAAK;IACL,OAAO,EAAP,kBAAO;IACP,GAAG,EAAH,cAAG;IACH,IAAI,EAAJ,eAAI;IACJ,MAAM,EAAN,iBAAM;IACN,MAAM,EAAN,iBAAM;IACN,OAAO,EAAP,qBAAO;IACP,SAAS;CACV,CAAC;AAEO,gBAAE"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4CAA8B;AAErB,gBAAE"}

package/lib/cjs/lib.d.ts

@@ -1,4 +1,8 @@
 import type { z } from "zod";
-type Brand<T> = T extends z.$brand<infer B> ? B : never;
-export type Unbranded<T> = T extends infer U & z.$brand<Brand<T>> ? Unbranded<U> : T;
-export {};
+/**
+ * A type utility that removes the brand from T.
+ *
+ * If T extends string & z.$brand<"BigToto">, then zu.unbranded<T> = T.
+ * Otherwise, zu.unbranded<T> = T.
+ */
+export type Unbranded<T> = T extends z.$brand<infer B> ? Omit<T, keyof z.$brand<B>> : T;

package/lib/cjs/type-guard.d.ts

@@ -0,0 +1,18 @@
+import type { TypeGuard } from "@infra-blocks/types";
+import type { z } from "zod";
+/**
+ * Returns a type guard function using the provided schema as the source of truth.
+ *
+ * It uses the `validate` function internally.
+ *
+ * @param schema - The schema used to verify the inputs will be of the correct type.
+ *
+ * @returns A type guard function that uses the provided schema to asserts whether the
+ * input is of the proper type or not.
+ *
+ * @note Type guards work best with branded types. Given two schemas, z.string().min(5),
+ * and z.string().min(5).brand("Min5String"), the former type guard would only assert
+ * that the input is string (even if the length check is also done), whereas in the
+ * former case, that information is also carried with the type.
+ */
+export declare function typeGuard<S extends z.ZodType>(schema: S): TypeGuard<z.infer<S>>;

package/lib/cjs/type-guard.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeGuard = typeGuard;
+const is_valid_js_1 = require("./is-valid.js");
+/**
+ * Returns a type guard function using the provided schema as the source of truth.
+ *
+ * It uses the `validate` function internally.
+ *
+ * @param schema - The schema used to verify the inputs will be of the correct type.
+ *
+ * @returns A type guard function that uses the provided schema to asserts whether the
+ * input is of the proper type or not.
+ *
+ * @note Type guards work best with branded types. Given two schemas, z.string().min(5),
+ * and z.string().min(5).brand("Min5String"), the former type guard would only assert
+ * that the input is string (even if the length check is also done), whereas in the
+ * former case, that information is also carried with the type.
+ */
+function typeGuard(schema) {
+    return (value) => {
+        return (0, is_valid_js_1.isValid)(schema, value);
+    };
+}
+//# sourceMappingURL=type-guard.js.map

package/lib/cjs/type-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guard.js","sourceRoot":"","sources":["../../src/type-guard.ts"],"names":[],"mappings":";;AAoBA,8BAMC;AAxBD,+CAAwC;AAExC;;;;;;;;;;;;;;GAcG;AAEH,SAAgB,SAAS,CACvB,MAAS;IAET,OAAO,CAAC,KAAc,EAAuB,EAAE;QAC7C,OAAO,IAAA,qBAAO,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAChC,CAAC,CAAC;AACJ,CAAC"}

package/lib/cjs/zu.d.ts

@@ -0,0 +1,19 @@
+import type { z } from "zod";
+export { aws } from "./aws/index.js";
+export { codec } from "./codec/index.js";
+export { geojson } from "./geojson/index.js";
+export { isValid } from "./is-valid.js";
+export { iso } from "./iso/index.js";
+export { json } from "./json/index.js";
+export { number } from "./number/index.js";
+export { string } from "./string/index.js";
+export { typeGuard } from "./type-guard.js";
+/**
+ * A type utility that infers the brand of a branded type.
+ *
+ * If T extends string & z.$brand<"BigToto">, then
+ * zu.interBrand<T> = "BigToto";
+ *
+ * If T is not branded, then this type utility resolves to `never`.
+ */
+export type inferBrand<T> = T extends z.$brand<infer B> ? B : never;

package/lib/cjs/zu.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeGuard = exports.string = exports.number = exports.json = exports.iso = exports.isValid = exports.geojson = exports.codec = exports.aws = void 0;
+var index_js_1 = require("./aws/index.js");
+Object.defineProperty(exports, "aws", { enumerable: true, get: function () { return index_js_1.aws; } });
+var index_js_2 = require("./codec/index.js");
+Object.defineProperty(exports, "codec", { enumerable: true, get: function () { return index_js_2.codec; } });
+var index_js_3 = require("./geojson/index.js");
+Object.defineProperty(exports, "geojson", { enumerable: true, get: function () { return index_js_3.geojson; } });
+var is_valid_js_1 = require("./is-valid.js");
+Object.defineProperty(exports, "isValid", { enumerable: true, get: function () { return is_valid_js_1.isValid; } });
+var index_js_4 = require("./iso/index.js");
+Object.defineProperty(exports, "iso", { enumerable: true, get: function () { return index_js_4.iso; } });
+var index_js_5 = require("./json/index.js");
+Object.defineProperty(exports, "json", { enumerable: true, get: function () { return index_js_5.json; } });
+var index_js_6 = require("./number/index.js");
+Object.defineProperty(exports, "number", { enumerable: true, get: function () { return index_js_6.number; } });
+var index_js_7 = require("./string/index.js");
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return index_js_7.string; } });
+var type_guard_js_1 = require("./type-guard.js");
+Object.defineProperty(exports, "typeGuard", { enumerable: true, get: function () { return type_guard_js_1.typeGuard; } });
+//# sourceMappingURL=zu.js.map

package/lib/cjs/zu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zu.js","sourceRoot":"","sources":["../../src/zu.ts"],"names":[],"mappings":";;;AAEA,2CAAqC;AAA5B,+FAAA,GAAG,OAAA;AACZ,6CAAyC;AAAhC,iGAAA,KAAK,OAAA;AACd,+CAA6C;AAApC,mGAAA,OAAO,OAAA;AAChB,6CAAwC;AAA/B,sGAAA,OAAO,OAAA;AAChB,2CAAqC;AAA5B,+FAAA,GAAG,OAAA;AACZ,4CAAuC;AAA9B,gGAAA,IAAI,OAAA;AACb,8CAA2C;AAAlC,kGAAA,MAAM,OAAA;AACf,8CAA2C;AAAlC,kGAAA,MAAM,OAAA;AACf,iDAA4C;AAAnC,0GAAA,SAAS,OAAA"}

package/lib/esm/index.d.ts

@@ -1,77 +1,2 @@
-import type { TypeGuard } from "@infra-blocks/types";
-import type { z } from "zod";
-import { isValid } from "./is-valid.js";
-/**
- * Returns a type guard function using the provided schema as the source of truth.
- *
- * It uses the `validate` function internally.
- *
- * @param schema - The schema used to verify the inputs will be of the correct type.
- *
- * @returns A type guard function that uses the provided schema to asserts whether the
- * input is of the proper type or not.
- *
- * @note Type guards work best with branded types. Given two schemas, z.string().min(5),
- * and z.string().min(5).brand("Min5String"), the former type guard would only assert
- * that the input is string (even if the length check is also done), whereas in the
- * former case, that information is also carried with the type.
- */
-declare function typeGuard<S extends z.ZodType>(schema: S): TypeGuard<z.infer<S>>;
-declare const zu: {
-    aws: {
-        accountId: typeof import("./aws/account-id.js").accountId;
-        arn: typeof import("./aws/arn.js").arn;
-        region: typeof import("./aws/region.js").region;
-        partition: typeof import("./aws/partition.js").partition;
-    };
-    codec: {
-        csv: () => z.ZodCodec<z.ZodString, z.ZodArray<z.ZodString>>;
-        jsonParse: <S extends z.ZodType>(schema: S) => z.ZodCodec<z.core.$ZodBranded<z.ZodString, "JsonString">, S>;
-        ms: (options?: {
-            long: boolean;
-        }) => z.ZodCodec<z.ZodString, z.ZodNumber>;
-        stringtoInteger: () => z.ZodCodec<z.core.$ZodBranded<z.ZodString, "IntegerString">, z.core.$ZodBranded<z.ZodInt, "Integer">>;
-        stringToJson: () => z.ZodCodec<z.core.$ZodBranded<z.ZodString, "JsonString">, z.ZodType<import("./json/json.js").Json, unknown, z.core.$ZodTypeInternals<import("./json/json.js").Json, unknown>>>;
-        stringToUrl: () => z.ZodCodec<z.core.$ZodBranded<z.ZodURL, "UrlString">, z.ZodCustom<import("url").URL, import("url").URL>>;
-    };
-    geojson: typeof import("./geojson/geojson.js").geojson & {
-        boundingBox: typeof import("./geojson/bounding-box.js").boundingBox;
-        feature: typeof import("./geojson/feature.js").feature;
-        featureCollection: typeof import("./geojson/feature-collection.js").featureCollection;
-        geometryCollection: typeof import("./geojson/geometry.js").geometryCollection;
-        lineString: typeof import("./geojson/line-string.js").lineString;
-        multiLineString: typeof import("./geojson/multi-line-string.js").multiLineString;
-        multiPoint: typeof import("./geojson/multi-point.js").multiPoint;
-        multiPolygon: typeof import("./geojson/multi-polygon.js").multiPolygon;
-        point: typeof import("./geojson/point.js").point;
-        polygon: typeof import("./geojson/polygon.js").polygon;
-        coordinate: typeof import("./geojson/coordinate.js").coordinate;
-    };
-    iso: {
-        currencyCode: () => z.core.$ZodBranded<z.ZodEnum<{
-            [x: string]: string;
-        }>, "IsoCurrencyCode">;
-        countryCode: {
-            alpha3: () => z.core.$ZodBranded<z.ZodEnum<{
-                [x: string]: string;
-            }>, "IsoAlpha3CountryCode">;
-        };
-    };
-    json: (() => z.ZodType<import("./json/json.js").Json, unknown, z.core.$ZodTypeInternals<import("./json/json.js").Json, unknown>>) & {
-        array: () => z.ZodArray<z.ZodType<import("./json/json.js").Json, unknown, z.core.$ZodTypeInternals<import("./json/json.js").Json, unknown>>>;
-        object: () => z.ZodRecord<z.ZodString, z.ZodType<import("./json/json.js").Json, unknown, z.core.$ZodTypeInternals<import("./json/json.js").Json, unknown>>>;
-        primitive: () => z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
-    };
-    number: {
-        integer: () => z.core.$ZodBranded<z.ZodInt, "Integer">;
-    };
-    string: {
-        integer: () => z.core.$ZodBranded<z.ZodString, "IntegerString">;
-        json: () => z.core.$ZodBranded<z.ZodString, "JsonString">;
-        number: () => z.core.$ZodBranded<z.ZodString, "NumberString">;
-        url: () => z.core.$ZodBranded<z.ZodURL, "UrlString">;
-    };
-    isValid: typeof isValid;
-    typeGuard: typeof typeGuard;
-};
+import * as zu from "./zu.js";
 export { zu };

package/lib/esm/index.js

@@ -1,41 +1,3 @@
-import { aws } from "./aws/index.js";
-import { codec } from "./codec/index.js";
-import { geojson } from "./geojson/index.js";
-import { isValid } from "./is-valid.js";
-import { iso } from "./iso/index.js";
-import { json } from "./json/index.js";
-import { number } from "./number/index.js";
-import { string } from "./string/index.js";
-/**
- * Returns a type guard function using the provided schema as the source of truth.
- *
- * It uses the `validate` function internally.
- *
- * @param schema - The schema used to verify the inputs will be of the correct type.
- *
- * @returns A type guard function that uses the provided schema to asserts whether the
- * input is of the proper type or not.
- *
- * @note Type guards work best with branded types. Given two schemas, z.string().min(5),
- * and z.string().min(5).brand("Min5String"), the former type guard would only assert
- * that the input is string (even if the length check is also done), whereas in the
- * former case, that information is also carried with the type.
- */
-function typeGuard(schema) {
-    return (value) => {
-        return isValid(schema, value);
-    };
-}
-const zu = {
-    aws,
-    codec,
-    geojson,
-    iso,
-    json,
-    number,
-    string,
-    isValid,
-    typeGuard,
-};
+import * as zu from "./zu.js";
 export { zu };
 //# sourceMappingURL=index.js.map

package/lib/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C;;;;;;;;;;;;;;GAcG;AACH,SAAS,SAAS,CAAsB,MAAS;IAC/C,OAAO,CAAC,KAAc,EAAuB,EAAE;QAC7C,OAAO,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAChC,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,EAAE,GAAG;IACT,GAAG;IACH,KAAK;IACL,OAAO;IACP,GAAG;IACH,IAAI;IACJ,MAAM;IACN,MAAM;IACN,OAAO;IACP,SAAS;CACV,CAAC;AAEF,OAAO,EAAE,EAAE,EAAE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAE9B,OAAO,EAAE,EAAE,EAAE,CAAC"}

package/lib/esm/lib.d.ts

@@ -1,4 +1,8 @@
 import type { z } from "zod";
-type Brand<T> = T extends z.$brand<infer B> ? B : never;
-export type Unbranded<T> = T extends infer U & z.$brand<Brand<T>> ? Unbranded<U> : T;
-export {};
+/**
+ * A type utility that removes the brand from T.
+ *
+ * If T extends string & z.$brand<"BigToto">, then zu.unbranded<T> = T.
+ * Otherwise, zu.unbranded<T> = T.
+ */
+export type Unbranded<T> = T extends z.$brand<infer B> ? Omit<T, keyof z.$brand<B>> : T;

package/lib/esm/type-guard.d.ts

@@ -0,0 +1,18 @@
+import type { TypeGuard } from "@infra-blocks/types";
+import type { z } from "zod";
+/**
+ * Returns a type guard function using the provided schema as the source of truth.
+ *
+ * It uses the `validate` function internally.
+ *
+ * @param schema - The schema used to verify the inputs will be of the correct type.
+ *
+ * @returns A type guard function that uses the provided schema to asserts whether the
+ * input is of the proper type or not.
+ *
+ * @note Type guards work best with branded types. Given two schemas, z.string().min(5),
+ * and z.string().min(5).brand("Min5String"), the former type guard would only assert
+ * that the input is string (even if the length check is also done), whereas in the
+ * former case, that information is also carried with the type.
+ */
+export declare function typeGuard<S extends z.ZodType>(schema: S): TypeGuard<z.infer<S>>;

package/lib/esm/type-guard.js

@@ -0,0 +1,22 @@
+import { isValid } from "./is-valid.js";
+/**
+ * Returns a type guard function using the provided schema as the source of truth.
+ *
+ * It uses the `validate` function internally.
+ *
+ * @param schema - The schema used to verify the inputs will be of the correct type.
+ *
+ * @returns A type guard function that uses the provided schema to asserts whether the
+ * input is of the proper type or not.
+ *
+ * @note Type guards work best with branded types. Given two schemas, z.string().min(5),
+ * and z.string().min(5).brand("Min5String"), the former type guard would only assert
+ * that the input is string (even if the length check is also done), whereas in the
+ * former case, that information is also carried with the type.
+ */
+export function typeGuard(schema) {
+    return (value) => {
+        return isValid(schema, value);
+    };
+}
+//# sourceMappingURL=type-guard.js.map

package/lib/esm/type-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guard.js","sourceRoot":"","sources":["../../src/type-guard.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC;;;;;;;;;;;;;;GAcG;AAEH,MAAM,UAAU,SAAS,CACvB,MAAS;IAET,OAAO,CAAC,KAAc,EAAuB,EAAE;QAC7C,OAAO,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAChC,CAAC,CAAC;AACJ,CAAC"}

package/lib/esm/zu.d.ts

@@ -0,0 +1,19 @@
+import type { z } from "zod";
+export { aws } from "./aws/index.js";
+export { codec } from "./codec/index.js";
+export { geojson } from "./geojson/index.js";
+export { isValid } from "./is-valid.js";
+export { iso } from "./iso/index.js";
+export { json } from "./json/index.js";
+export { number } from "./number/index.js";
+export { string } from "./string/index.js";
+export { typeGuard } from "./type-guard.js";
+/**
+ * A type utility that infers the brand of a branded type.
+ *
+ * If T extends string & z.$brand<"BigToto">, then
+ * zu.interBrand<T> = "BigToto";
+ *
+ * If T is not branded, then this type utility resolves to `never`.
+ */
+export type inferBrand<T> = T extends z.$brand<infer B> ? B : never;

package/lib/esm/zu.js

@@ -0,0 +1,10 @@
+export { aws } from "./aws/index.js";
+export { codec } from "./codec/index.js";
+export { geojson } from "./geojson/index.js";
+export { isValid } from "./is-valid.js";
+export { iso } from "./iso/index.js";
+export { json } from "./json/index.js";
+export { number } from "./number/index.js";
+export { string } from "./string/index.js";
+export { typeGuard } from "./type-guard.js";
+//# sourceMappingURL=zu.js.map

package/lib/esm/zu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zu.js","sourceRoot":"","sources":["../../src/zu.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infra-blocks/zod-utils",
-  "version": "0.23.1",
+  "version": "0.24.0-alpha.0",
   "description": "Extensions to the zod package.",
   "keywords": [
     "zod",