bguard 0.0.2 → 0.0.4

package/lib/asserts/number/max.mjs

@@ -0,0 +1,27 @@
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/asserts/number/max.ts
+var max = (expected) => (received, pathToError) => {
+  if (expected < received)
+    throwException(expected, received, pathToError, "The received value is greater than expected");
+};
+export {
+  max
+};
+//# sourceMappingURL=max.mjs.map

package/lib/asserts/number/max.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions.ts","../../../src/asserts/number/max.ts"],"sourcesContent":["export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n","import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a number value does not exceed a specified maximum value.\n *\n * @param {number} expected - The maximum allowable value.\n * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value exceeds the expected maximum value.\n *\n * @example\n * const schema = number().custom(max(100));\n * parseSchema(schema, 99);  // Valid\n * parseSchema(schema, 100); // Valid\n * parseSchema(schema, 101); // Throws an error: 'The received value is greater than expected'\n */\nexport const max =\n  (expected: number): RequiredValidation =>\n  (received: number, pathToError: string) => {\n    if (expected < received)\n      throwException(expected, received, pathToError, 'The received value is greater than expected');\n  };\n"],"mappings":";AAAO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,UAAmB,UAAmB,aAAqB,SAAiB;AACtF,UAAM;AACN,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AACnB,SAAK,UAAU;AAAA,EACjB;AACF;AAIO,SAAS,eAAe,UAAmB,UAAmB,aAAqB,SAAwB;AAChH,QAAM,IAAI,gBAAgB,UAAU,UAAU,aAAa,OAAO;AACpE;;;ACHO,IAAM,MACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,WAAW;AACb,mBAAe,UAAU,UAAU,aAAa,6CAA6C;AACjG;","names":[]}

package/lib/asserts/number/maxExcluded.d.mts

@@ -0,0 +1,17 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.mjs';
+
+/**
+ * Asserts that a number value is strictly less than a specified maximum value (i.e., the maximum value is excluded).
+ *
+ * @param {number} expected - The maximum allowable value, which is excluded.
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is greater than or equal to the expected maximum value.
+ *
+ * @example
+ * const schema = number().custom(maxExcluded(100));
+ * parseSchema(schema, 99);  // Valid
+ * parseSchema(schema, 100); // Throws an error: 'The received value is greater than or equal to expected'
+ * parseSchema(schema, 101); // Throws an error: 'The received value is greater than or equal to expected'
+ */
+declare const maxExcluded: (expected: number) => RequiredValidation;
+
+export { maxExcluded };

package/lib/asserts/number/maxExcluded.d.ts

@@ -0,0 +1,17 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.js';
+
+/**
+ * Asserts that a number value is strictly less than a specified maximum value (i.e., the maximum value is excluded).
+ *
+ * @param {number} expected - The maximum allowable value, which is excluded.
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is greater than or equal to the expected maximum value.
+ *
+ * @example
+ * const schema = number().custom(maxExcluded(100));
+ * parseSchema(schema, 99);  // Valid
+ * parseSchema(schema, 100); // Throws an error: 'The received value is greater than or equal to expected'
+ * parseSchema(schema, 101); // Throws an error: 'The received value is greater than or equal to expected'
+ */
+declare const maxExcluded: (expected: number) => RequiredValidation;
+
+export { maxExcluded };

package/lib/asserts/number/maxExcluded.js

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/asserts/number/maxExcluded.ts
+var maxExcluded_exports = {};
+__export(maxExcluded_exports, {
+  maxExcluded: () => maxExcluded
+});
+module.exports = __toCommonJS(maxExcluded_exports);
+
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/asserts/number/maxExcluded.ts
+var maxExcluded = (expected) => (received, pathToError) => {
+  if (expected <= received)
+    throwException(expected, received, pathToError, "The received value is greater than or equal to expected");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  maxExcluded
+});
+//# sourceMappingURL=maxExcluded.js.map

package/lib/asserts/number/maxExcluded.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/asserts/number/maxExcluded.ts","../../../src/exceptions.ts"],"sourcesContent":["import { throwException } from '../../exceptions';\nimport { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a number value is strictly less than a specified maximum value (i.e., the maximum value is excluded).\n *\n * @param {number} expected - The maximum allowable value, which is excluded.\n * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is greater than or equal to the expected maximum value.\n *\n * @example\n * const schema = number().custom(maxExcluded(100));\n * parseSchema(schema, 99);  // Valid\n * parseSchema(schema, 100); // Throws an error: 'The received value is greater than or equal to expected'\n * parseSchema(schema, 101); // Throws an error: 'The received value is greater than or equal to expected'\n */\nexport const maxExcluded =\n  (expected: number): RequiredValidation =>\n  (received: number, pathToError: string) => {\n    if (expected <= received)\n      throwException(expected, received, pathToError, 'The received value is greater than or equal to expected');\n  };\n","export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,UAAmB,UAAmB,aAAqB,SAAiB;AACtF,UAAM;AACN,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AACnB,SAAK,UAAU;AAAA,EACjB;AACF;AAIO,SAAS,eAAe,UAAmB,UAAmB,aAAqB,SAAwB;AAChH,QAAM,IAAI,gBAAgB,UAAU,UAAU,aAAa,OAAO;AACpE;;;ADHO,IAAM,cACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,YAAY;AACd,mBAAe,UAAU,UAAU,aAAa,yDAAyD;AAC7G;","names":[]}

package/lib/asserts/number/maxExcluded.mjs

@@ -0,0 +1,27 @@
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/asserts/number/maxExcluded.ts
+var maxExcluded = (expected) => (received, pathToError) => {
+  if (expected <= received)
+    throwException(expected, received, pathToError, "The received value is greater than or equal to expected");
+};
+export {
+  maxExcluded
+};
+//# sourceMappingURL=maxExcluded.mjs.map

package/lib/asserts/number/maxExcluded.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions.ts","../../../src/asserts/number/maxExcluded.ts"],"sourcesContent":["export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n","import { throwException } from '../../exceptions';\nimport { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a number value is strictly less than a specified maximum value (i.e., the maximum value is excluded).\n *\n * @param {number} expected - The maximum allowable value, which is excluded.\n * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is greater than or equal to the expected maximum value.\n *\n * @example\n * const schema = number().custom(maxExcluded(100));\n * parseSchema(schema, 99);  // Valid\n * parseSchema(schema, 100); // Throws an error: 'The received value is greater than or equal to expected'\n * parseSchema(schema, 101); // Throws an error: 'The received value is greater than or equal to expected'\n */\nexport const maxExcluded =\n  (expected: number): RequiredValidation =>\n  (received: number, pathToError: string) => {\n    if (expected <= received)\n      throwException(expected, received, pathToError, 'The received value is greater than or equal to expected');\n  };\n"],"mappings":";AAAO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,UAAmB,UAAmB,aAAqB,SAAiB;AACtF,UAAM;AACN,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AACnB,SAAK,UAAU;AAAA,EACjB;AACF;AAIO,SAAS,eAAe,UAAmB,UAAmB,aAAqB,SAAwB;AAChH,QAAM,IAAI,gBAAgB,UAAU,UAAU,aAAa,OAAO;AACpE;;;ACHO,IAAM,cACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,YAAY;AACd,mBAAe,UAAU,UAAU,aAAa,yDAAyD;AAC7G;","names":[]}

package/lib/asserts/number/min.d.mts

@@ -0,0 +1,17 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.mjs';
+
+/**
+ * Asserts that a number value is not less than a specified minimum value.
+ *
+ * @param {number} expected - The minimum allowable value.
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is less than the expected minimum value.
+ *
+ * @example
+ * const schema = number().custom(min(10));
+ * parseSchema(schema, 11);  // Valid
+ * parseSchema(schema, 10);  // Valid
+ * parseSchema(schema, 9);   // Throws an error: 'The received value is less than expected'
+ */
+declare const min: (expected: number) => RequiredValidation;
+
+export { min };

package/lib/asserts/number/min.d.ts

@@ -0,0 +1,17 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.js';
+
+/**
+ * Asserts that a number value is not less than a specified minimum value.
+ *
+ * @param {number} expected - The minimum allowable value.
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is less than the expected minimum value.
+ *
+ * @example
+ * const schema = number().custom(min(10));
+ * parseSchema(schema, 11);  // Valid
+ * parseSchema(schema, 10);  // Valid
+ * parseSchema(schema, 9);   // Throws an error: 'The received value is less than expected'
+ */
+declare const min: (expected: number) => RequiredValidation;
+
+export { min };

package/lib/asserts/number/min.js

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/asserts/number/min.ts
+var min_exports = {};
+__export(min_exports, {
+  min: () => min
+});
+module.exports = __toCommonJS(min_exports);
+
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/asserts/number/min.ts
+var min = (expected) => (received, pathToError) => {
+  if (expected > received)
+    throwException(expected, received, pathToError, "The received value is less than expected");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  min
+});
+//# sourceMappingURL=min.js.map

package/lib/asserts/number/min.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/asserts/number/min.ts","../../../src/exceptions.ts"],"sourcesContent":["import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a number value is not less than a specified minimum value.\n *\n * @param {number} expected - The minimum allowable value.\n * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is less than the expected minimum value.\n *\n * @example\n * const schema = number().custom(min(10));\n * parseSchema(schema, 11);  // Valid\n * parseSchema(schema, 10);  // Valid\n * parseSchema(schema, 9);   // Throws an error: 'The received value is less than expected'\n */\nexport const min =\n  (expected: number): RequiredValidation =>\n  (received: number, pathToError: string) => {\n    if (expected > received)\n      throwException(expected, received, pathToError, 'The received value is less than expected');\n  };\n","export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,UAAmB,UAAmB,aAAqB,SAAiB;AACtF,UAAM;AACN,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AACnB,SAAK,UAAU;AAAA,EACjB;AACF;AAIO,SAAS,eAAe,UAAmB,UAAmB,aAAqB,SAAwB;AAChH,QAAM,IAAI,gBAAgB,UAAU,UAAU,aAAa,OAAO;AACpE;;;ADHO,IAAM,MACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,WAAW;AACb,mBAAe,UAAU,UAAU,aAAa,0CAA0C;AAC9F;","names":[]}

package/lib/asserts/number/min.mjs

@@ -0,0 +1,27 @@
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/asserts/number/min.ts
+var min = (expected) => (received, pathToError) => {
+  if (expected > received)
+    throwException(expected, received, pathToError, "The received value is less than expected");
+};
+export {
+  min
+};
+//# sourceMappingURL=min.mjs.map

package/lib/asserts/number/min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions.ts","../../../src/asserts/number/min.ts"],"sourcesContent":["export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n","import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a number value is not less than a specified minimum value.\n *\n * @param {number} expected - The minimum allowable value.\n * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is less than the expected minimum value.\n *\n * @example\n * const schema = number().custom(min(10));\n * parseSchema(schema, 11);  // Valid\n * parseSchema(schema, 10);  // Valid\n * parseSchema(schema, 9);   // Throws an error: 'The received value is less than expected'\n */\nexport const min =\n  (expected: number): RequiredValidation =>\n  (received: number, pathToError: string) => {\n    if (expected > received)\n      throwException(expected, received, pathToError, 'The received value is less than expected');\n  };\n"],"mappings":";AAAO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,UAAmB,UAAmB,aAAqB,SAAiB;AACtF,UAAM;AACN,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AACnB,SAAK,UAAU;AAAA,EACjB;AACF;AAIO,SAAS,eAAe,UAAmB,UAAmB,aAAqB,SAAwB;AAChH,QAAM,IAAI,gBAAgB,UAAU,UAAU,aAAa,OAAO;AACpE;;;ACHO,IAAM,MACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,WAAW;AACb,mBAAe,UAAU,UAAU,aAAa,0CAA0C;AAC9F;","names":[]}

package/lib/asserts/number/minExcluded.d.mts

@@ -0,0 +1,17 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.mjs';
+
+/**
+ * Asserts that a number value is strictly greater than a specified minimum value (i.e., the minimum value is excluded).
+ *
+ * @param {number} expected - The minimum allowable value, which is excluded.
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is less than or equal to the expected minimum value.
+ *
+ * @example
+ * const schema = number().custom(minExcluded(10));
+ * parseSchema(schema, 11);  // Valid
+ * parseSchema(schema, 10); // Throws an error: 'The received value is less than or equal to expected'
+ * parseSchema(schema, 9);  // Throws an error: 'The received value is less than or equal to expected'
+ */
+declare const minExcluded: (expected: number) => RequiredValidation;
+
+export { minExcluded };

package/lib/asserts/number/minExcluded.d.ts

@@ -0,0 +1,17 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.js';
+
+/**
+ * Asserts that a number value is strictly greater than a specified minimum value (i.e., the minimum value is excluded).
+ *
+ * @param {number} expected - The minimum allowable value, which is excluded.
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is less than or equal to the expected minimum value.
+ *
+ * @example
+ * const schema = number().custom(minExcluded(10));
+ * parseSchema(schema, 11);  // Valid
+ * parseSchema(schema, 10); // Throws an error: 'The received value is less than or equal to expected'
+ * parseSchema(schema, 9);  // Throws an error: 'The received value is less than or equal to expected'
+ */
+declare const minExcluded: (expected: number) => RequiredValidation;
+
+export { minExcluded };

package/lib/asserts/number/minExcluded.js

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/asserts/number/minExcluded.ts
+var minExcluded_exports = {};
+__export(minExcluded_exports, {
+  minExcluded: () => minExcluded
+});
+module.exports = __toCommonJS(minExcluded_exports);
+
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/asserts/number/minExcluded.ts
+var minExcluded = (expected) => (received, pathToError) => {
+  if (expected >= received)
+    throwException(expected, received, pathToError, "The received value is less than or equal to expected");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  minExcluded
+});
+//# sourceMappingURL=minExcluded.js.map

package/lib/asserts/number/minExcluded.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/asserts/number/minExcluded.ts","../../../src/exceptions.ts"],"sourcesContent":["import { throwException } from '../../exceptions';\nimport { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a number value is strictly greater than a specified minimum value (i.e., the minimum value is excluded).\n *\n * @param {number} expected - The minimum allowable value, which is excluded.\n * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is less than or equal to the expected minimum value.\n *\n * @example\n * const schema = number().custom(minExcluded(10));\n * parseSchema(schema, 11);  // Valid\n * parseSchema(schema, 10); // Throws an error: 'The received value is less than or equal to expected'\n * parseSchema(schema, 9);  // Throws an error: 'The received value is less than or equal to expected'\n */\nexport const minExcluded =\n  (expected: number): RequiredValidation =>\n  (received: number, pathToError: string) => {\n    if (expected >= received)\n      throwException(expected, received, pathToError, 'The received value is less than or equal to expected');\n  };\n","export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,UAAmB,UAAmB,aAAqB,SAAiB;AACtF,UAAM;AACN,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AACnB,SAAK,UAAU;AAAA,EACjB;AACF;AAIO,SAAS,eAAe,UAAmB,UAAmB,aAAqB,SAAwB;AAChH,QAAM,IAAI,gBAAgB,UAAU,UAAU,aAAa,OAAO;AACpE;;;ADHO,IAAM,cACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,YAAY;AACd,mBAAe,UAAU,UAAU,aAAa,sDAAsD;AAC1G;","names":[]}

package/lib/asserts/number/minExcluded.mjs

@@ -0,0 +1,27 @@
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/asserts/number/minExcluded.ts
+var minExcluded = (expected) => (received, pathToError) => {
+  if (expected >= received)
+    throwException(expected, received, pathToError, "The received value is less than or equal to expected");
+};
+export {
+  minExcluded
+};
+//# sourceMappingURL=minExcluded.mjs.map

package/lib/asserts/number/minExcluded.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions.ts","../../../src/asserts/number/minExcluded.ts"],"sourcesContent":["export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n","import { throwException } from '../../exceptions';\nimport { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a number value is strictly greater than a specified minimum value (i.e., the minimum value is excluded).\n *\n * @param {number} expected - The minimum allowable value, which is excluded.\n * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is less than or equal to the expected minimum value.\n *\n * @example\n * const schema = number().custom(minExcluded(10));\n * parseSchema(schema, 11);  // Valid\n * parseSchema(schema, 10); // Throws an error: 'The received value is less than or equal to expected'\n * parseSchema(schema, 9);  // Throws an error: 'The received value is less than or equal to expected'\n */\nexport const minExcluded =\n  (expected: number): RequiredValidation =>\n  (received: number, pathToError: string) => {\n    if (expected >= received)\n      throwException(expected, received, pathToError, 'The received value is less than or equal to expected');\n  };\n"],"mappings":";AAAO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,UAAmB,UAAmB,aAAqB,SAAiB;AACtF,UAAM;AACN,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AACnB,SAAK,UAAU;AAAA,EACjB;AACF;AAIO,SAAS,eAAe,UAAmB,UAAmB,aAAqB,SAAwB;AAChH,QAAM,IAAI,gBAAgB,UAAU,UAAU,aAAa,OAAO;AACpE;;;ACHO,IAAM,cACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,YAAY;AACd,mBAAe,UAAU,UAAU,aAAa,sDAAsD;AAC1G;","names":[]}

package/lib/asserts/number/negative.d.mts

@@ -0,0 +1,16 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.mjs';
+
+/**
+ * Asserts that a number value is negative (less than zero).
+ *
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is not negative.
+ *
+ * @example
+ * const schema = number().custom(negative());
+ * parseSchema(schema, -10); // Valid
+ * parseSchema(schema, 0);  // Throws an error: 'The received value is not a negative number'
+ * parseSchema(schema, 5);  // Throws an error: 'The received value is not a negative number'
+ */
+declare const negative: () => RequiredValidation;
+
+export { negative };

package/lib/asserts/number/negative.d.ts

@@ -0,0 +1,16 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.js';
+
+/**
+ * Asserts that a number value is negative (less than zero).
+ *
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is not negative.
+ *
+ * @example
+ * const schema = number().custom(negative());
+ * parseSchema(schema, -10); // Valid
+ * parseSchema(schema, 0);  // Throws an error: 'The received value is not a negative number'
+ * parseSchema(schema, 5);  // Throws an error: 'The received value is not a negative number'
+ */
+declare const negative: () => RequiredValidation;
+
+export { negative };

package/lib/asserts/number/negative.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/asserts/number/negative.ts
+var negative_exports = {};
+__export(negative_exports, {
+  negative: () => negative
+});
+module.exports = __toCommonJS(negative_exports);
+
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/asserts/number/negative.ts
+var negative = () => (received, pathToError) => {
+  if (received >= 0) throwException("negative", received, pathToError, "The received value is not a negative number");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  negative
+});
+//# sourceMappingURL=negative.js.map

package/lib/asserts/number/negative.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/asserts/number/negative.ts","../../../src/exceptions.ts"],"sourcesContent":["import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a number value is negative (less than zero).\n *\n * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is not negative.\n *\n * @example\n * const schema = number().custom(negative());\n * parseSchema(schema, -10); // Valid\n * parseSchema(schema, 0);  // Throws an error: 'The received value is not a negative number'\n * parseSchema(schema, 5);  // Throws an error: 'The received value is not a negative number'\n */\nexport const negative = (): RequiredValidation => (received: number, pathToError: string) => {\n  if (received >= 0) throwException('negative', received, pathToError, 'The received value is not a negative number');\n};\n","export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,UAAmB,UAAmB,aAAqB,SAAiB;AACtF,UAAM;AACN,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AACnB,SAAK,UAAU;AAAA,EACjB;AACF;AAIO,SAAS,eAAe,UAAmB,UAAmB,aAAqB,SAAwB;AAChH,QAAM,IAAI,gBAAgB,UAAU,UAAU,aAAa,OAAO;AACpE;;;ADJO,IAAM,WAAW,MAA0B,CAAC,UAAkB,gBAAwB;AAC3F,MAAI,YAAY,EAAG,gBAAe,YAAY,UAAU,aAAa,6CAA6C;AACpH;","names":[]}

package/lib/asserts/number/negative.mjs

@@ -0,0 +1,26 @@
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/asserts/number/negative.ts
+var negative = () => (received, pathToError) => {
+  if (received >= 0) throwException("negative", received, pathToError, "The received value is not a negative number");
+};
+export {
+  negative
+};
+//# sourceMappingURL=negative.mjs.map

package/lib/asserts/number/negative.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions.ts","../../../src/asserts/number/negative.ts"],"sourcesContent":["export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n","import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a number value is negative (less than zero).\n *\n * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is not negative.\n *\n * @example\n * const schema = number().custom(negative());\n * parseSchema(schema, -10); // Valid\n * parseSchema(schema, 0);  // Throws an error: 'The received value is not a negative number'\n * parseSchema(schema, 5);  // Throws an error: 'The received value is not a negative number'\n */\nexport const negative = (): RequiredValidation => (received: number, pathToError: string) => {\n  if (received >= 0) throwException('negative', received, pathToError, 'The received value is not a negative number');\n};\n"],"mappings":";AAAO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,UAAmB,UAAmB,aAAqB,SAAiB;AACtF,UAAM;AACN,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,cAAc;AACnB,SAAK,UAAU;AAAA,EACjB;AACF;AAIO,SAAS,eAAe,UAAmB,UAAmB,aAAqB,SAAwB;AAChH,QAAM,IAAI,gBAAgB,UAAU,UAAU,aAAa,OAAO;AACpE;;;ACJO,IAAM,WAAW,MAA0B,CAAC,UAAkB,gBAAwB;AAC3F,MAAI,YAAY,EAAG,gBAAe,YAAY,UAAU,aAAa,6CAA6C;AACpH;","names":[]}

package/lib/asserts/number/positive.d.mts

@@ -0,0 +1,16 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.mjs';
+
+/**
+ * Asserts that a number value is positive (greater than zero).
+ *
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is not positive.
+ *
+ * @example
+ * const schema = number().custom(positive());
+ * parseSchema(schema, 10);  // Valid
+ * parseSchema(schema, 0);  // Throws an error: 'The received value is not a positive number'
+ * parseSchema(schema, -5); // Throws an error: 'The received value is not a positive number'
+ */
+declare const positive: () => RequiredValidation;
+
+export { positive };

package/lib/asserts/number/positive.d.ts

@@ -0,0 +1,16 @@
+import { R as RequiredValidation } from '../../CommonSchema-DeTBsQhn.js';
+
+/**
+ * Asserts that a number value is positive (greater than zero).
+ *
+ * @returns {RequiredValidation} - A validation function that takes a received number and a path to the error message. Throws an error if the received value is not positive.
+ *
+ * @example
+ * const schema = number().custom(positive());
+ * parseSchema(schema, 10);  // Valid
+ * parseSchema(schema, 0);  // Throws an error: 'The received value is not a positive number'
+ * parseSchema(schema, -5); // Throws an error: 'The received value is not a positive number'
+ */
+declare const positive: () => RequiredValidation;
+
+export { positive };