umt 2.17.0 → 2.18.0

package/module/Validate/object/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./core";
 export * from "./intersection";
+export * from "./nullable";
 export * from "./optional";
 export * from "./union";

package/module/Validate/object/index.js

@@ -1,5 +1,6 @@
 export * from "./core";
 export * from "./intersection";
+export * from "./nullable";
 export * from "./optional";
 export * from "./union";
 //# sourceMappingURL=index.js.map

package/module/Validate/object/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/object/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/object/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}

package/module/Validate/object/intersection.d.ts

@@ -1,6 +1,8 @@
 import type { UnionToIntersection } from "../../types/logic";
-import type { ValidateCoreReturnType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * Creates an intersection validator that passes only if all given validators pass
  * @param validators - Validator functions to compose as an intersection (logical AND)

package/module/Validate/object/intersection.js.map

@@ -1 +1 @@
-{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../../src/Validate/object/intersection.ts"],"names":[],"mappings":"AASA;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAG1B,GAAG,UAAmB,EACtB,EAAE;IACF,OAAO,CACL,KAA4D,EAG5D,EAAE;QACF,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,MAAM,GACV,SAKD,CAAC,KAAK,CAAC,CAAC;YACT,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACrB,OAAO;oBACL,QAAQ,EAAE,KAAK;oBACf,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,IAAI,EAAE,KAEL;iBACF,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAEL;SACF,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../../src/Validate/object/intersection.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAG1B,GAAG,UAAmB,EACtB,EAAE;IACF,OAAO,CACL,KAA4D,EAG5D,EAAE;QACF,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,MAAM,GACV,SAKD,CAAC,KAAK,CAAC,CAAC;YACT,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACrB,OAAO;oBACL,QAAQ,EAAE,KAAK;oBACf,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,IAAI,EAAE,KAEL;iBACF,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAEL;SACF,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

package/module/Validate/object/nullable.d.ts

@@ -0,0 +1,8 @@
+import type { ValidateCoreReturnType } from "../../Validate/type";
+/**
+ * Wraps a validator to accept null values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make nullable
+ * @returns {Function} - Validator that passes for null or delegates to the wrapped validator
+ */
+export declare const nullable: <T>(validator: (value: T) => ValidateCoreReturnType<T>) => ((value: T | null) => ValidateCoreReturnType<T | null>);

package/module/Validate/object/nullable.js

@@ -0,0 +1,21 @@
+/**
+ * Wraps a validator to accept null values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make nullable
+ * @returns {Function} - Validator that passes for null or delegates to the wrapped validator
+ */
+export const nullable = (validator) => {
+    const nullableValidator = (value) => {
+        if (value === null) {
+            return {
+                validate: true,
+                message: "",
+                type: "null",
+            };
+        }
+        const result = validator(value);
+        return result;
+    };
+    return nullableValidator;
+};
+//# sourceMappingURL=nullable.js.map

package/module/Validate/object/nullable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullable.js","sourceRoot":"","sources":["../../../src/Validate/object/nullable.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,SAAkD,EACO,EAAE;IAC3D,MAAM,iBAAiB,GAAG,CACxB,KAAe,EACmB,EAAE;QACpC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO;gBACL,QAAQ,EAAE,IAAI;gBACd,OAAO,EAAE,EAAE;gBACX,IAAI,EAAE,MAAM;aACb,CAAC;QACJ,CAAC;QACD,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QAChC,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IAEF,OAAO,iBAAiB,CAAC;AAC3B,CAAC,CAAC"}

package/module/Validate/object/union.d.ts

@@ -1,5 +1,7 @@
-import type { ValidateCoreReturnType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * Creates a union validator that passes if any of the given validators pass
  * @param validators - Validator functions to compose as a union (logical OR)

package/module/Validate/object/union.js.map

@@ -1 +1 @@
-{"version":3,"file":"union.js","sourceRoot":"","sources":["../../../src/Validate/object/union.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAGnB,GAAG,UAAmB,EACtB,EAAE;IACF,OAAO,CACL,KAAuC,EACmB,EAAE;QAC5D,IAAI,WAAW,GAAG,EAAE,CAAC;QACrB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,MAAM,GACV,SAGD,CAAC,KAAK,CAAC,CAAC;YACT,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACpB,OAAO;oBACL,QAAQ,EAAE,IAAI;oBACd,OAAO,EAAE,EAAE;oBACX,IAAI,EAAE,KAA2D;iBAClE,CAAC;YACJ,CAAC;YACD,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;QAC/B,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,WAAW;YACpB,IAAI,EAAE,KAA2D;SAClE,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"union.js","sourceRoot":"","sources":["../../../src/Validate/object/union.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAGnB,GAAG,UAAmB,EACtB,EAAE;IACF,OAAO,CACL,KAAuC,EACmB,EAAE;QAC5D,IAAI,WAAW,GAAG,EAAE,CAAC;QACrB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,MAAM,GACV,SAGD,CAAC,KAAK,CAAC,CAAC;YACT,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACpB,OAAO;oBACL,QAAQ,EAAE,IAAI;oBACd,OAAO,EAAE,EAAE;oBACX,IAAI,EAAE,KAA2D;iBAClE,CAAC;YACJ,CAAC;YACD,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;QAC/B,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,WAAW;YACpB,IAAI,EAAE,KAA2D;SAClE,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

package/module/Validate/string/index.d.ts

@@ -4,5 +4,6 @@ export * from "./length";
 export * from "./minLength";
 export * from "./maxLength";
 export * from "./numberString";
+export * from "./oneOf";
 export * from "./regexMatch";
 export * from "./uuid";

package/module/Validate/string/index.js

@@ -4,6 +4,7 @@ export * from "./length";
 export * from "./minLength";
 export * from "./maxLength";
 export * from "./numberString";
+export * from "./oneOf";
 export * from "./regexMatch";
 export * from "./uuid";
 //# sourceMappingURL=index.js.map

package/module/Validate/string/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/string/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/string/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC"}

package/module/Validate/string/oneOf.d.ts

@@ -0,0 +1,32 @@
+/**
+ * String validation module for literal union (allowed values) check
+ * Provides validation functionality for checking if a string is one of the
+ * allowed literal values, useful for validating string literal union types
+ * such as `'standard' | 'squat' | 'decanter' | 'round' | 'tall' | 'flask'`.
+ *
+ * The validator's return type carries the literal union through its `type`
+ * field directly (instead of going through `Types<T>` which would collapse
+ * to `"string"`), so consumers like `object()`, `union()`, and `intersection()`
+ * can preserve the literal union in their inferred types.
+ */
+/**
+ * Return type produced by a `oneOf` validator. Structurally compatible with
+ * `ValidateCoreReturnType<unknown>`, but exposes the literal union directly
+ * via the `type` field so the inferred type can flow through `object()`,
+ * `union()`, and `intersection()` without being collapsed to `string`.
+ */
+export interface OneOfReturnType<T extends string> {
+    validate: boolean;
+    message: string;
+    type: T;
+}
+/**
+ * Creates a top-level validator that checks if a string value is one of the
+ * given allowed literal values. The literal union is captured via `const T`
+ * and exposed through the `OneOfReturnType<T[number]>` return type.
+ * @template T - The tuple of allowed string literals
+ * @param {T} values - The tuple of allowed string values
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns A validator function from `string` to `OneOfReturnType<T[number]>`
+ */
+export declare const oneOf: <const T extends readonly string[]>(values: T, message?: string) => (value: string) => OneOfReturnType<T[number]>;

package/module/Validate/string/oneOf.js

@@ -0,0 +1,32 @@
+/**
+ * String validation module for literal union (allowed values) check
+ * Provides validation functionality for checking if a string is one of the
+ * allowed literal values, useful for validating string literal union types
+ * such as `'standard' | 'squat' | 'decanter' | 'round' | 'tall' | 'flask'`.
+ *
+ * The validator's return type carries the literal union through its `type`
+ * field directly (instead of going through `Types<T>` which would collapse
+ * to `"string"`), so consumers like `object()`, `union()`, and `intersection()`
+ * can preserve the literal union in their inferred types.
+ */
+/**
+ * Creates a top-level validator that checks if a string value is one of the
+ * given allowed literal values. The literal union is captured via `const T`
+ * and exposed through the `OneOfReturnType<T[number]>` return type.
+ * @template T - The tuple of allowed string literals
+ * @param {T} values - The tuple of allowed string values
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns A validator function from `string` to `OneOfReturnType<T[number]>`
+ */
+export const oneOf = (values, message) => {
+    const allowed = new Set(values);
+    return (value) => {
+        const isValid = allowed.has(value);
+        return {
+            validate: isValid,
+            message: isValid ? "" : (message ?? ""),
+            type: value,
+        };
+    };
+};
+//# sourceMappingURL=oneOf.js.map

package/module/Validate/string/oneOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oneOf.js","sourceRoot":"","sources":["../../../src/Validate/string/oneOf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAcH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,MAAS,EACT,OAAgB,EAChB,EAAE;IACF,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,MAAM,CAAC,CAAC;IACxC,OAAO,CAAC,KAAa,EAA8B,EAAE;QACnD,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACnC,OAAO;YACL,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC;YACvC,IAAI,EAAE,KAAK;SACZ,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

package/module/es5/Validate/object/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./core";
 export * from "./intersection";
+export * from "./nullable";
 export * from "./optional";
 export * from "./union";

package/module/es5/Validate/object/index.js

@@ -25,6 +25,17 @@ Object.keys(_intersection).forEach(function (key) {
     }
   });
 });
+var _nullable = require("./nullable");
+Object.keys(_nullable).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _nullable[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _nullable[key];
+    }
+  });
+});
 var _optional = require("./optional");
 Object.keys(_optional).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Validate/object/intersection.d.ts

@@ -1,6 +1,8 @@
 import type { UnionToIntersection } from "../../types/logic";
-import type { ValidateCoreReturnType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * Creates an intersection validator that passes only if all given validators pass
  * @param validators - Validator functions to compose as an intersection (logical AND)

package/module/es5/Validate/object/intersection.js

@@ -4,6 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.intersection = void 0;
+// Extract the validated value type by reading the validator's `type` field
+// (and applying `ValidateType` to map type tags like "string" back to the
+// runtime type). Reading the field directly lets validators that expose the
+// literal union via the `type` field (such as `oneOf`) flow through
+// intersection without being collapsed by `Types<T>`.
+
 /**
  * Creates an intersection validator that passes only if all given validators pass
  * @param validators - Validator functions to compose as an intersection (logical AND)

package/module/es5/Validate/object/nullable.d.ts

@@ -0,0 +1,8 @@
+import type { ValidateCoreReturnType } from "../../Validate/type";
+/**
+ * Wraps a validator to accept null values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make nullable
+ * @returns {Function} - Validator that passes for null or delegates to the wrapped validator
+ */
+export declare const nullable: <T>(validator: (value: T) => ValidateCoreReturnType<T>) => ((value: T | null) => ValidateCoreReturnType<T | null>);

package/module/es5/Validate/object/nullable.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nullable = void 0;
+/**
+ * Wraps a validator to accept null values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make nullable
+ * @returns {Function} - Validator that passes for null or delegates to the wrapped validator
+ */
+var nullable = exports.nullable = function nullable(validator) {
+  var nullableValidator = function nullableValidator(value) {
+    if (value === null) {
+      return {
+        validate: true,
+        message: "",
+        type: "null"
+      };
+    }
+    var result = validator(value);
+    return result;
+  };
+  return nullableValidator;
+};

package/module/es5/Validate/object/union.d.ts

@@ -1,5 +1,7 @@
-import type { ValidateCoreReturnType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * Creates a union validator that passes if any of the given validators pass
  * @param validators - Validator functions to compose as a union (logical OR)

package/module/es5/Validate/object/union.js

@@ -4,6 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.union = void 0;
+// Extract the validated value type by reading the validator's `type` field
+// (and applying `ValidateType` to map type tags like "string" back to the
+// runtime type). Reading the field directly lets validators that expose the
+// literal union via the `type` field (such as `oneOf`) flow through union
+// without being collapsed by `Types<T>`.
+
 /**
  * Creates a union validator that passes if any of the given validators pass
  * @param validators - Validator functions to compose as a union (logical OR)

package/module/es5/Validate/string/index.d.ts

@@ -4,5 +4,6 @@ export * from "./length";
 export * from "./minLength";
 export * from "./maxLength";
 export * from "./numberString";
+export * from "./oneOf";
 export * from "./regexMatch";
 export * from "./uuid";

package/module/es5/Validate/string/index.js

@@ -69,6 +69,17 @@ Object.keys(_numberString).forEach(function (key) {
     }
   });
 });
+var _oneOf = require("./oneOf");
+Object.keys(_oneOf).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _oneOf[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _oneOf[key];
+    }
+  });
+});
 var _regexMatch = require("./regexMatch");
 Object.keys(_regexMatch).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Validate/string/oneOf.d.ts

@@ -0,0 +1,32 @@
+/**
+ * String validation module for literal union (allowed values) check
+ * Provides validation functionality for checking if a string is one of the
+ * allowed literal values, useful for validating string literal union types
+ * such as `'standard' | 'squat' | 'decanter' | 'round' | 'tall' | 'flask'`.
+ *
+ * The validator's return type carries the literal union through its `type`
+ * field directly (instead of going through `Types<T>` which would collapse
+ * to `"string"`), so consumers like `object()`, `union()`, and `intersection()`
+ * can preserve the literal union in their inferred types.
+ */
+/**
+ * Return type produced by a `oneOf` validator. Structurally compatible with
+ * `ValidateCoreReturnType<unknown>`, but exposes the literal union directly
+ * via the `type` field so the inferred type can flow through `object()`,
+ * `union()`, and `intersection()` without being collapsed to `string`.
+ */
+export interface OneOfReturnType<T extends string> {
+    validate: boolean;
+    message: string;
+    type: T;
+}
+/**
+ * Creates a top-level validator that checks if a string value is one of the
+ * given allowed literal values. The literal union is captured via `const T`
+ * and exposed through the `OneOfReturnType<T[number]>` return type.
+ * @template T - The tuple of allowed string literals
+ * @param {T} values - The tuple of allowed string values
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns A validator function from `string` to `OneOfReturnType<T[number]>`
+ */
+export declare const oneOf: <const T extends readonly string[]>(values: T, message?: string) => (value: string) => OneOfReturnType<T[number]>;

package/module/es5/Validate/string/oneOf.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.oneOf = void 0;
+/**
+ * String validation module for literal union (allowed values) check
+ * Provides validation functionality for checking if a string is one of the
+ * allowed literal values, useful for validating string literal union types
+ * such as `'standard' | 'squat' | 'decanter' | 'round' | 'tall' | 'flask'`.
+ *
+ * The validator's return type carries the literal union through its `type`
+ * field directly (instead of going through `Types<T>` which would collapse
+ * to `"string"`), so consumers like `object()`, `union()`, and `intersection()`
+ * can preserve the literal union in their inferred types.
+ */
+
+/**
+ * Return type produced by a `oneOf` validator. Structurally compatible with
+ * `ValidateCoreReturnType<unknown>`, but exposes the literal union directly
+ * via the `type` field so the inferred type can flow through `object()`,
+ * `union()`, and `intersection()` without being collapsed to `string`.
+ */
+
+/**
+ * Creates a top-level validator that checks if a string value is one of the
+ * given allowed literal values. The literal union is captured via `const T`
+ * and exposed through the `OneOfReturnType<T[number]>` return type.
+ * @template T - The tuple of allowed string literals
+ * @param {T} values - The tuple of allowed string values
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns A validator function from `string` to `OneOfReturnType<T[number]>`
+ */
+var oneOf = exports.oneOf = function oneOf(values, message) {
+  var allowed = new Set(values);
+  return function (value) {
+    var isValid = allowed.has(value);
+    return {
+      validate: isValid,
+      message: isValid ? "" : message !== null && message !== void 0 ? message : "",
+      type: value
+    };
+  };
+};

package/package.json

@@ -37,6 +37,8 @@
     "ts-node": "10.9.2",
     "tsc-alias": "1.8.16",
     "typedoc": "0.28.19",
+    "typedoc-github-wiki-theme": "2.1.0",
+    "typedoc-plugin-markdown": "4.11.0",
     "typescript": "6.0.3",
     "typescript-eslint": "8.59.1"
   },
@@ -217,11 +219,12 @@
     "format": "nix develop --command make format",
     "lint": "nix develop --command make lint",
     "lint:ci": "nix develop --command make lint-ci",
+    "readme": "nix develop --command make readme",
     "test": "nix develop --command make test",
     "test-debug": "nix develop --command make test-debug",
     "ts-node": "nix develop --command make ts-node"
   },
   "type": "module",
   "types": "module/index.d.ts",
-  "version": "2.17.0"
+  "version": "2.18.0"
 }