bguard 0.0.5 → 0.0.6

package/lib/asserts/string/minLength.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/asserts/string/minLength.ts","../../../src/exceptions.ts"],"sourcesContent":["import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that the length of a string value is not less than a specified minimum length.\n *\n * @param {number} expected - The minimum required length for the string.\n * @returns {RequiredValidation} - A validation function that takes a received string and a path to the error message. Throws an error if the length of the received value is less than the expected length.\n *\n * @example\n * const schema = string().custom(minLength(5));\n * parseSchema(schema, 'short');   // Throws an error: 'The received value length is less than expected'\n * parseSchema(schema, 'adequate'); // Valid\n */\nexport const minLength =\n  (expected: number): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (received.length < expected)\n      throwException(expected, received, pathToError, 'The received value length 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;;;ADJO,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,SAAS,SAAS;AACpB,mBAAe,UAAU,UAAU,aAAa,iDAAiD;AACrG;","names":[]}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/minLength.js","../../../src/asserts/string/minLength.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACA;ACUO,IAAM,UAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,WAAA,EAAA,GAAwB;AACzC,EAAA,GAAA,CAAI,QAAA,CAAS,OAAA,EAAS,QAAA;AACpB,IAAA,6CAAA,QAAe,EAAU,QAAA,EAAU,WAAA,EAAa,iDAAiD,CAAA;AACrG,CAAA;ADVF;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/minLength.js","sourcesContent":[null,"import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that the length of a string value is not less than a specified minimum length.\n *\n * @param {number} expected - The minimum required length for the string.\n * @returns {RequiredValidation} - A validation function that takes a received string and a path to the error message. Throws an error if the length of the received value is less than the expected length.\n *\n * @example\n * const schema = string().custom(minLength(5));\n * parseSchema(schema, 'short');   // Throws an error: 'The received value length is less than expected'\n * parseSchema(schema, 'adequate'); // Valid\n */\nexport const minLength =\n  (expected: number): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (received.length < expected)\n      throwException(expected, received, pathToError, 'The received value length is less than expected');\n  };\n"]}

package/lib/asserts/string/minLength.mjs

@@ -1,20 +1,6 @@
-// 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);
-}
+import {
+  throwException
+} from "../../chunk-QJOXKH7A.mjs";
 
 // src/asserts/string/minLength.ts
 var minLength = (expected) => (received, pathToError) => {

package/lib/asserts/string/minLength.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/exceptions.ts","../../../src/asserts/string/minLength.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 the length of a string value is not less than a specified minimum length.\n *\n * @param {number} expected - The minimum required length for the string.\n * @returns {RequiredValidation} - A validation function that takes a received string and a path to the error message. Throws an error if the length of the received value is less than the expected length.\n *\n * @example\n * const schema = string().custom(minLength(5));\n * parseSchema(schema, 'short');   // Throws an error: 'The received value length is less than expected'\n * parseSchema(schema, 'adequate'); // Valid\n */\nexport const minLength =\n  (expected: number): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (received.length < expected)\n      throwException(expected, received, pathToError, 'The received value length 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;;;ACJO,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,SAAS,SAAS;AACpB,mBAAe,UAAU,UAAU,aAAa,iDAAiD;AACrG;","names":[]}
+{"version":3,"sources":["../../../src/asserts/string/minLength.ts"],"sourcesContent":["import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that the length of a string value is not less than a specified minimum length.\n *\n * @param {number} expected - The minimum required length for the string.\n * @returns {RequiredValidation} - A validation function that takes a received string and a path to the error message. Throws an error if the length of the received value is less than the expected length.\n *\n * @example\n * const schema = string().custom(minLength(5));\n * parseSchema(schema, 'short');   // Throws an error: 'The received value length is less than expected'\n * parseSchema(schema, 'adequate'); // Valid\n */\nexport const minLength =\n  (expected: number): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (received.length < expected)\n      throwException(expected, received, pathToError, 'The received value length is less than expected');\n  };\n"],"mappings":";;;;;AAcO,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,SAAS,SAAS;AACpB,mBAAe,UAAU,UAAU,aAAa,iDAAiD;AACrG;","names":[]}

package/lib/asserts/string/regExp.js

@@ -1,54 +1,13 @@
-"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);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/asserts/string/regExp.ts
-var regExp_exports = {};
-__export(regExp_exports, {
-  regExp: () => regExp
-});
-module.exports = __toCommonJS(regExp_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);
-}
+var _chunk2AP4OQMTjs = require('../../chunk-2AP4OQMT.js');
 
 // src/asserts/string/regExp.ts
 var regExp = (expected) => (received, pathToError) => {
   if (!expected.test(received))
-    throwException(expected, received, pathToError, "The received value does not match the required text pattern");
+    _chunk2AP4OQMTjs.throwException.call(void 0, expected, received, pathToError, "The received value does not match the required text pattern");
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  regExp
-});
+
+
+exports.regExp = regExp;
 //# sourceMappingURL=regExp.js.map

package/lib/asserts/string/regExp.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/asserts/string/regExp.ts","../../../src/exceptions.ts"],"sourcesContent":["import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a string value matches a specified regular expression pattern.\n *\n * @param {RegExp} expected - The regular expression pattern that the string value should match.\n * @returns {RequiredValidation} - A validation function that takes a received string and a path to the error message. Throws an error if the received value does not match the expected pattern.\n *\n * @example\n * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern\n * parseSchema(schema, 'valid123'); // Valid\n * parseSchema(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'\n */\nexport const regExp =\n  (expected: RegExp): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (!expected.test(received))\n      throwException(expected, received, pathToError, 'The received value does not match the required text pattern');\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,SACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,CAAC,SAAS,KAAK,QAAQ;AACzB,mBAAe,UAAU,UAAU,aAAa,6DAA6D;AACjH;","names":[]}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/regExp.js","../../../src/asserts/string/regExp.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACA;ACUO,IAAM,OAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,WAAA,EAAA,GAAwB;AACzC,EAAA,GAAA,CAAI,CAAC,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA;AACzB,IAAA,6CAAA,QAAe,EAAU,QAAA,EAAU,WAAA,EAAa,6DAA6D,CAAA;AACjH,CAAA;ADVF;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/regExp.js","sourcesContent":[null,"import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a string value matches a specified regular expression pattern.\n *\n * @param {RegExp} expected - The regular expression pattern that the string value should match.\n * @returns {RequiredValidation} - A validation function that takes a received string and a path to the error message. Throws an error if the received value does not match the expected pattern.\n *\n * @example\n * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern\n * parseSchema(schema, 'valid123'); // Valid\n * parseSchema(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'\n */\nexport const regExp =\n  (expected: RegExp): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (!expected.test(received))\n      throwException(expected, received, pathToError, 'The received value does not match the required text pattern');\n  };\n"]}

package/lib/asserts/string/regExp.mjs

@@ -1,20 +1,6 @@
-// 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);
-}
+import {
+  throwException
+} from "../../chunk-QJOXKH7A.mjs";
 
 // src/asserts/string/regExp.ts
 var regExp = (expected) => (received, pathToError) => {

package/lib/asserts/string/regExp.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/exceptions.ts","../../../src/asserts/string/regExp.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 string value matches a specified regular expression pattern.\n *\n * @param {RegExp} expected - The regular expression pattern that the string value should match.\n * @returns {RequiredValidation} - A validation function that takes a received string and a path to the error message. Throws an error if the received value does not match the expected pattern.\n *\n * @example\n * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern\n * parseSchema(schema, 'valid123'); // Valid\n * parseSchema(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'\n */\nexport const regExp =\n  (expected: RegExp): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (!expected.test(received))\n      throwException(expected, received, pathToError, 'The received value does not match the required text pattern');\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,SACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,CAAC,SAAS,KAAK,QAAQ;AACzB,mBAAe,UAAU,UAAU,aAAa,6DAA6D;AACjH;","names":[]}
+{"version":3,"sources":["../../../src/asserts/string/regExp.ts"],"sourcesContent":["import { throwException } from '../../exceptions';\nimport type { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Asserts that a string value matches a specified regular expression pattern.\n *\n * @param {RegExp} expected - The regular expression pattern that the string value should match.\n * @returns {RequiredValidation} - A validation function that takes a received string and a path to the error message. Throws an error if the received value does not match the expected pattern.\n *\n * @example\n * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern\n * parseSchema(schema, 'valid123'); // Valid\n * parseSchema(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'\n */\nexport const regExp =\n  (expected: RegExp): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (!expected.test(received))\n      throwException(expected, received, pathToError, 'The received value does not match the required text pattern');\n  };\n"],"mappings":";;;;;AAcO,IAAM,SACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,CAAC,SAAS,KAAK,QAAQ;AACzB,mBAAe,UAAU,UAAU,aAAa,6DAA6D;AACjH;","names":[]}

package/lib/chunk-2AP4OQMT.js

@@ -0,0 +1,26 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/exceptions.ts
+var ValidationError = class extends Error {
+  
+  
+  
+  
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+var BuildSchemaError = class extends Error {
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+
+
+
+
+exports.ValidationError = ValidationError; exports.BuildSchemaError = BuildSchemaError; exports.throwException = throwException;
+//# sourceMappingURL=chunk-2AP4OQMT.js.map

package/lib/chunk-2AP4OQMT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-2AP4OQMT.js","../src/exceptions.ts"],"names":[],"mappings":"AAAA;ACAO,IAAM,gBAAA,EAAN,MAAA,QAA8B,MAAM;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,WAAA,CAAY,QAAA,EAAmB,QAAA,EAAmB,WAAA,EAAqB,OAAA,EAAiB;AACtF,IAAA,KAAA,CAAM,CAAA;AACN,IAAA,IAAA,CAAK,SAAA,EAAW,QAAA;AAChB,IAAA,IAAA,CAAK,SAAA,EAAW,QAAA;AAChB,IAAA,IAAA,CAAK,YAAA,EAAc,WAAA;AACnB,IAAA,IAAA,CAAK,QAAA,EAAU,OAAA;AAAA,EACjB;AACF,CAAA;AAEO,IAAM,iBAAA,EAAN,MAAA,QAA+B,MAAM;AAAC,CAAA;AAEtC,SAAS,cAAA,CAAe,QAAA,EAAmB,QAAA,EAAmB,WAAA,EAAqB,OAAA,EAAwB;AAChH,EAAA,MAAM,IAAI,eAAA,CAAgB,QAAA,EAAU,QAAA,EAAU,WAAA,EAAa,OAAO,CAAA;AACpE;ADCA;AACA;AACE;AACA;AACA;AACF,gIAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-2AP4OQMT.js","sourcesContent":[null,"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"]}

package/lib/chunk-32IQXZRK.mjs

@@ -0,0 +1,13 @@
+import {
+  ObjectSchema
+} from "./chunk-QYLH5ZAC.mjs";
+
+// src/asserts/object/index.ts
+function object(shapeSchema) {
+  return new ObjectSchema({ type: [], requiredValidations: [] }, shapeSchema);
+}
+
+export {
+  object
+};
+//# sourceMappingURL=chunk-32IQXZRK.mjs.map

package/lib/chunk-32IQXZRK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/object/index.ts"],"sourcesContent":["import { ObjectShapeSchemaType } from '../../schemas/CommonSchema';\nimport { ObjectSchema, WithObject } from '../../schemas/ObjectSchema';\n\n/**\n * Creates a new schema for validating objects where each property must match the specified schema.\n *\n * @template T\n * @param {T} shapeSchema - The schema that each property of the object must match.\n * @returns {WithObject<T>} A new instance of `ObjectSchema` for validating objects with properties matching the specified schema.\n *\n * @example\n * const schema = object({\n *   name: string(),\n *   age: number()\n * });\n * parseSchema(schema, { name: 'John', age: 30 }); // Validates successfully\n * parseSchema(schema, { name: 'John', age: '30' }); // Throws a validation error\n */\nexport function object<T extends ObjectShapeSchemaType>(shapeSchema: T): WithObject<T> {\n  return new ObjectSchema({ type: [], requiredValidations: [] }, shapeSchema) as WithObject<T>;\n}\n"],"mappings":";;;;;AAkBO,SAAS,OAAwC,aAA+B;AACrF,SAAO,IAAI,aAAa,EAAE,MAAM,CAAC,GAAG,qBAAqB,CAAC,EAAE,GAAG,WAAW;AAC5E;","names":[]}

package/lib/chunk-3FEJUC3K.mjs

@@ -0,0 +1,13 @@
+import {
+  BooleanSchema
+} from "./chunk-GEZME6V2.mjs";
+
+// src/asserts/boolean/index.ts
+function boolean() {
+  return new BooleanSchema({ type: ["boolean"], requiredValidations: [] });
+}
+
+export {
+  boolean
+};
+//# sourceMappingURL=chunk-3FEJUC3K.mjs.map

package/lib/chunk-3FEJUC3K.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/boolean/index.ts"],"sourcesContent":["import { BooleanSchema } from '../../schemas/BooleanSchema';\n\n/**\n * Creates a new schema for validating boolean values.\n *\n * @returns {BooleanSchema} A new instance of `BooleanSchema` for validating booleans.\n *\n * @example\n * const schema = boolean();\n * parseSchema(schema, true); // Validates successfully\n * parseSchema(schema, 'true'); // Throws a validation error\n */\nexport function boolean(): BooleanSchema {\n  return new BooleanSchema({ type: ['boolean'], requiredValidations: [] });\n}\n"],"mappings":";;;;;AAYO,SAAS,UAAyB;AACvC,SAAO,IAAI,cAAc,EAAE,MAAM,CAAC,SAAS,GAAG,qBAAqB,CAAC,EAAE,CAAC;AACzE;","names":[]}

package/lib/chunk-5NCJN6D2.js

@@ -0,0 +1,70 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk2AP4OQMTjs = require('./chunk-2AP4OQMT.js');
+
+// src/core.ts
+var ctxSymbol = Symbol("contextSymbol");
+function innerCheck(schema, receivedValue, pathToError) {
+  const ctx = schema[ctxSymbol];
+  if (receivedValue === void 0) {
+    if (!ctx.isOptional) _chunk2AP4OQMTjs.throwException.call(void 0, "Required", receivedValue, pathToError, "The required value is missing");
+    return receivedValue;
+  }
+  if (receivedValue === null) {
+    if (!ctx.isNullable) _chunk2AP4OQMTjs.throwException.call(void 0, "Not null", receivedValue, pathToError, "Value should not be null");
+    return receivedValue;
+  }
+  if (ctx.array) {
+    if (!Array.isArray(receivedValue))
+      _chunk2AP4OQMTjs.throwException.call(void 0, "Array", receivedValue, pathToError, "Expected an array but received a different type");
+    const schema2 = ctx.array;
+    receivedValue.forEach((elem, i) => {
+      innerCheck(schema2, elem, `${pathToError}[${i}]`);
+    });
+    return receivedValue;
+  }
+  const typeOfVal = typeof receivedValue;
+  if (ctx.object) {
+    if (typeOfVal !== "object")
+      _chunk2AP4OQMTjs.throwException.call(void 0, "Object", receivedValue, pathToError, "Expected an object but received a different type");
+    if (Array.isArray(receivedValue))
+      _chunk2AP4OQMTjs.throwException.call(void 0, 
+        "Object",
+        receivedValue,
+        pathToError,
+        "Expected an object but received an array. Invalid type of data"
+      );
+    const shapeSchema = ctx.object;
+    for (const keyPerReceivedValue of Object.keys(receivedValue)) {
+      if (shapeSchema[keyPerReceivedValue] === void 0)
+        _chunk2AP4OQMTjs.throwException.call(void 0, "Not allowed", keyPerReceivedValue, pathToError, "This key is not allowed in the object");
+    }
+    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {
+      const receivedObjectValuePropery = receivedValue[keyOfSchema];
+      if (receivedObjectValuePropery === void 0) {
+        if (!valueOfSchema[ctxSymbol].isOptional)
+          _chunk2AP4OQMTjs.throwException.call(void 0, 
+            "Required",
+            receivedObjectValuePropery,
+            pathToError,
+            "Missing required property in the object"
+          );
+      }
+      innerCheck(valueOfSchema, receivedObjectValuePropery, `${pathToError}.${keyOfSchema}`);
+    }
+    return receivedValue;
+  }
+  if (ctx.type.length) {
+    if (!ctx.type.includes(typeOfVal)) _chunk2AP4OQMTjs.throwException.call(void 0, ctx.type, typeOfVal, pathToError, "Invalid type of data");
+  }
+  ctx.requiredValidations.forEach((requiredValidation) => {
+    requiredValidation(receivedValue, pathToError);
+  });
+  return receivedValue;
+}
+
+
+
+
+exports.ctxSymbol = ctxSymbol; exports.innerCheck = innerCheck;
+//# sourceMappingURL=chunk-5NCJN6D2.js.map

package/lib/chunk-5NCJN6D2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-5NCJN6D2.js","../src/core.ts"],"names":["schema"],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACJO,IAAM,UAAA,EAAY,MAAA,CAAO,eAAe,CAAA;AAKxC,SAAS,UAAA,CAAW,MAAA,EAAsB,aAAA,EAAwB,WAAA,EAAqB;AAC5F,EAAA,MAAM,IAAA,EAAM,MAAA,CAAO,SAAS,CAAA;AAC5B,EAAA,GAAA,CAAI,cAAA,IAAkB,KAAA,CAAA,EAAW;AAC/B,IAAA,GAAA,CAAI,CAAC,GAAA,CAAI,UAAA,EAAY,6CAAA,UAAe,EAAY,aAAA,EAAe,WAAA,EAAa,+BAA+B,CAAA;AAC3G,IAAA,OAAO,aAAA;AAAA,EACT;AAEA,EAAA,GAAA,CAAI,cAAA,IAAkB,IAAA,EAAM;AAC1B,IAAA,GAAA,CAAI,CAAC,GAAA,CAAI,UAAA,EAAY,6CAAA,UAAe,EAAY,aAAA,EAAe,WAAA,EAAa,0BAA0B,CAAA;AACtG,IAAA,OAAO,aAAA;AAAA,EACT;AAEA,EAAA,GAAA,CAAI,GAAA,CAAI,KAAA,EAAO;AACb,IAAA,GAAA,CAAI,CAAC,KAAA,CAAM,OAAA,CAAQ,aAAa,CAAA;AAC9B,MAAA,6CAAA,OAAe,EAAS,aAAA,EAAe,WAAA,EAAa,iDAAiD,CAAA;AACvG,IAAA,MAAMA,QAAAA,EAAS,GAAA,CAAI,KAAA;AAEnB,IAAA,aAAA,CAAc,OAAA,CAAQ,CAAC,IAAA,EAAM,CAAA,EAAA,GAAM;AACjC,MAAA,UAAA,CAAWA,OAAAA,EAAQ,IAAA,EAAM,CAAA,EAAA;AAC1B,IAAA;AAEM,IAAA;AACT,EAAA;AAEyB,EAAA;AAET,EAAA;AACI,IAAA;AACS,MAAA;AACT,IAAA;AAChB,MAAA;AACE,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACF,MAAA;AACsB,IAAA;AACb,IAAA;AACO,MAAA;AACC,QAAA;AACnB,IAAA;AAEyB,IAAA;AACjB,MAAA;AACF,MAAA;AACiB,QAAA;AACjB,UAAA;AACE,YAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACF,UAAA;AACJ,MAAA;AAC0B,MAAA;AAC5B,IAAA;AAEO,IAAA;AACT,EAAA;AAEqB,EAAA;AACI,IAAA;AACzB,EAAA;AAEwB,EAAA;AACH,IAAA;AACpB,EAAA;AAEM,EAAA;AACT;ADTiC;AACA;AACA;AACA;AACA","file":"/home/runner/work/bguard/bguard/lib/chunk-5NCJN6D2.js","sourcesContent":[null,"export const ctxSymbol = Symbol('contextSymbol');\n\nimport { throwException } from './exceptions';\nimport type { CommonSchema } from './schemas/CommonSchema';\n\nexport function innerCheck(schema: CommonSchema, receivedValue: unknown, pathToError: string) {\n  const ctx = schema[ctxSymbol];\n  if (receivedValue === undefined) {\n    if (!ctx.isOptional) throwException('Required', receivedValue, pathToError, 'The required value is missing');\n    return receivedValue;\n  }\n\n  if (receivedValue === null) {\n    if (!ctx.isNullable) throwException('Not null', receivedValue, pathToError, 'Value should not be null');\n    return receivedValue;\n  }\n\n  if (ctx.array) {\n    if (!Array.isArray(receivedValue))\n      throwException('Array', receivedValue, pathToError, 'Expected an array but received a different type');\n    const schema = ctx.array;\n\n    receivedValue.forEach((elem, i) => {\n      innerCheck(schema, elem, `${pathToError}[${i}]`);\n    });\n\n    return receivedValue;\n  }\n\n  const typeOfVal = typeof receivedValue;\n\n  if (ctx.object) {\n    if (typeOfVal !== 'object')\n      throwException('Object', receivedValue, pathToError, 'Expected an object but received a different type');\n    if (Array.isArray(receivedValue))\n      throwException(\n        'Object',\n        receivedValue,\n        pathToError,\n        'Expected an object but received an array. Invalid type of data',\n      );\n    const shapeSchema = ctx.object;\n    for (const keyPerReceivedValue of Object.keys(receivedValue)) {\n      if (shapeSchema[keyPerReceivedValue] === undefined)\n        throwException('Not allowed', keyPerReceivedValue, pathToError, 'This key is not allowed in the object');\n    }\n\n    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {\n      const receivedObjectValuePropery = (receivedValue as Record<string, unknown>)[keyOfSchema];\n      if (receivedObjectValuePropery === undefined) {\n        if (!valueOfSchema[ctxSymbol].isOptional)\n          throwException(\n            'Required',\n            receivedObjectValuePropery,\n            pathToError,\n            'Missing required property in the object',\n          );\n      }\n      innerCheck(valueOfSchema, receivedObjectValuePropery, `${pathToError}.${keyOfSchema}`);\n    }\n\n    return receivedValue;\n  }\n\n  if (ctx.type.length) {\n    if (!ctx.type.includes(typeOfVal)) throwException(ctx.type, typeOfVal, pathToError, 'Invalid type of data');\n  }\n\n  ctx.requiredValidations.forEach((requiredValidation) => {\n    requiredValidation(receivedValue, pathToError);\n  });\n\n  return receivedValue;\n}\n"]}

package/lib/chunk-5ZMICHV3.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5NCJN6D2js = require('./chunk-5NCJN6D2.js');
+
+
+var _chunk2AP4OQMTjs = require('./chunk-2AP4OQMT.js');
+
+// src/parseSchema.ts
+function parseSchema(schema, receivedValue) {
+  try {
+    return _chunk5NCJN6D2js.innerCheck.call(void 0, schema, receivedValue, "");
+  } catch (e) {
+    if (e instanceof _chunk2AP4OQMTjs.ValidationError) throw e;
+    throw new Error("Something unexpected happened");
+  }
+}
+
+
+
+exports.parseSchema = parseSchema;
+//# sourceMappingURL=chunk-5ZMICHV3.js.map

package/lib/chunk-5ZMICHV3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-5ZMICHV3.js","../src/parseSchema.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACwBO,SAAS,WAAA,CAAoC,MAAA,EAAW,aAAA,EAAsC;AACnG,EAAA,IAAI;AACF,IAAA,OAAO,yCAAA,MAAW,EAAQ,aAAA,EAAe,EAAE,CAAA;AAAA,EAC7C,EAAA,MAAA,CAAS,CAAA,EAAG;AACV,IAAA,GAAA,CAAI,EAAA,WAAa,gCAAA,EAAiB,MAAM,CAAA;AAExC,IAAA,MAAM,IAAI,KAAA,CAAM,+BAA+B,CAAA;AAAA,EACjD;AACF;ADvBA;AACA;AACE;AACF,kCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-5ZMICHV3.js","sourcesContent":[null,"import { InferType } from './InferType';\nimport { innerCheck } from './core';\nimport { ValidationError } from './exceptions';\nimport { CommonSchema } from './schemas/CommonSchema';\n\n/**\n * Parses and validates a value against the provided schema, returning a type-safe result.\n *\n * This function will throw a `ValidationError` if the value does not conform to the schema.\n * The inferred TypeScript type of the returned value will match the structure defined by the schema.\n *\n * @template T\n * @param {T} schema - The schema to validate the received value against. This schema dictates the expected structure and type of the value.\n * @param {unknown} receivedValue - The value to be validated and parsed according to the schema.\n * @returns {InferType<T>} The validated value, with its TypeScript type inferred from the schema.\n *\n * @throws {ValidationError} If the received value does not match the schema, a `ValidationError` will be thrown.\n * @throws {Error} If an unexpected error occurs during validation, an error will be thrown with a generic message.\n *\n * @example\n * const schema = object({\n *   name: string(),\n *   age: number(),\n * });\n *\n * const result = parseSchema(schema, { name: 'Alice', age: 30 });\n * // result will be inferred as { name: string; age: number }\n *\n * parseSchema(schema, { name: 'Alice', age: '30' });\n * // Throws ValidationError because 'age' should be a number, not a string.\n */\nexport function parseSchema<T extends CommonSchema>(schema: T, receivedValue: unknown): InferType<T> {\n  try {\n    return innerCheck(schema, receivedValue, '') as InferType<T>;\n  } catch (e) {\n    if (e instanceof ValidationError) throw e;\n    /* istanbul ignore next */\n    throw new Error('Something unexpected happened');\n  }\n}\n"]}

package/lib/chunk-63IQFNFO.mjs

@@ -0,0 +1,27 @@
+import {
+  equalTo
+} from "./chunk-FCFO5J5Y.mjs";
+import {
+  CommonSchema
+} from "./chunk-L7HUXYFV.mjs";
+
+// src/schemas/NumberSchema.ts
+var NumberSchema = class extends CommonSchema {
+  _number = 1;
+  /**
+   * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+   *
+   * @param expectedValue - The value that the schema must exactly match.
+   * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   *
+   * @example - number().equalTo(42); // Infers the type 42
+   */
+  equalTo(expectedValue) {
+    return this.custom(equalTo(expectedValue));
+  }
+};
+
+export {
+  NumberSchema
+};
+//# sourceMappingURL=chunk-63IQFNFO.mjs.map

package/lib/chunk-63IQFNFO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas/NumberSchema.ts"],"sourcesContent":["import { equalTo } from '../asserts/common/equalTo';\n\nimport { CommonSchema } from './CommonSchema';\n\nexport class NumberSchema extends CommonSchema {\n  _number = 1;\n\n  /**\n   * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.\n   *\n   * @param expectedValue - The value that the schema must exactly match.\n   * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type\n   *\n   * @example - number().equalTo(42); // Infers the type 42\n   */\n  equalTo<Y extends number>(expectedValue: Y): WithNumber<this, Y> {\n    return this.custom(equalTo(expectedValue)) as WithNumber<this, Y>;\n  }\n}\n\nexport type WithNumber<T extends NumberSchema, Y = number> = T & { validation_number: Y };\nexport type ExtractFromNumber<T> = T extends WithNumber<NumberSchema, infer Y> ? Y : never;\n"],"mappings":";;;;;;;;AAIO,IAAM,eAAN,cAA2B,aAAa;AAAA,EAC7C,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUV,QAA0B,eAAuC;AAC/D,WAAO,KAAK,OAAO,QAAQ,aAAa,CAAC;AAAA,EAC3C;AACF;","names":[]}

package/lib/chunk-A2SAWKJA.mjs

@@ -0,0 +1,13 @@
+import {
+  ArraySchema
+} from "./chunk-A3UTB4RE.mjs";
+
+// src/asserts/array/index.ts
+function array(arraySchema) {
+  return new ArraySchema({ type: [], requiredValidations: [] }, arraySchema);
+}
+
+export {
+  array
+};
+//# sourceMappingURL=chunk-A2SAWKJA.mjs.map

package/lib/chunk-A2SAWKJA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/array/index.ts"],"sourcesContent":["import { ArraySchema, WithArray } from '../../schemas/ArraySchema';\nimport { CommonSchema } from '../../schemas/CommonSchema';\n\n/**\n * Creates a new schema for validating arrays where each element must match the specified schema.\n *\n * @template T\n * @param {T} arraySchema - The schema that each element of the array must match.\n * @returns {WithArray<T>} A new instance of `ArraySchema` for validating arrays of elements that match the specified schema.\n *\n * @example\n * const schema = array(string());\n * parseSchema(schema, ['hello', 'world']); // Validates successfully\n * parseSchema(schema, ['hello', 123]); // Throws a validation error\n */\nexport function array<T extends CommonSchema>(arraySchema: T): WithArray<T> {\n  return new ArraySchema({ type: [], requiredValidations: [] }, arraySchema) as WithArray<T>;\n}\n"],"mappings":";;;;;AAeO,SAAS,MAA8B,aAA8B;AAC1E,SAAO,IAAI,YAAY,EAAE,MAAM,CAAC,GAAG,qBAAqB,CAAC,EAAE,GAAG,WAAW;AAC3E;","names":[]}

package/lib/chunk-A3UTB4RE.mjs

@@ -0,0 +1,28 @@
+import {
+  CommonSchema
+} from "./chunk-L7HUXYFV.mjs";
+import {
+  ctxSymbol
+} from "./chunk-P3Y6IWFA.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-QJOXKH7A.mjs";
+
+// src/schemas/ArraySchema.ts
+var ArraySchema = class extends CommonSchema {
+  _array = 1;
+  constructor(ctx, arraySchema) {
+    super(ctx);
+    this.validateArrayEntry(arraySchema);
+    this[ctxSymbol].array = arraySchema;
+  }
+  validateArrayEntry(arraySchema) {
+    if (!arraySchema) throw new BuildSchemaError("Missing schema in array method");
+    if (!(arraySchema instanceof CommonSchema)) throw new BuildSchemaError("Invalid schema in array method");
+  }
+};
+
+export {
+  ArraySchema
+};
+//# sourceMappingURL=chunk-A3UTB4RE.mjs.map

package/lib/chunk-A3UTB4RE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas/ArraySchema.ts"],"sourcesContent":["import { ctxSymbol } from '../core';\nimport { BuildSchemaError } from '../exceptions';\nimport { CommonSchema, ValidatorContext } from './CommonSchema';\n\nexport class ArraySchema extends CommonSchema {\n  _array = 1;\n  constructor(ctx: ValidatorContext, arraySchema: CommonSchema) {\n    super(ctx);\n    this.validateArrayEntry(arraySchema);\n    this[ctxSymbol].array = arraySchema;\n  }\n\n  private validateArrayEntry(arraySchema: CommonSchema) {\n    if (!arraySchema) throw new BuildSchemaError('Missing schema in array method');\n    if (!(arraySchema instanceof CommonSchema)) throw new BuildSchemaError('Invalid schema in array method');\n  }\n}\n\nexport type WithArray<Y extends CommonSchema> = ArraySchema & { validation_array: Y };\nexport type ExtractFromArray<T> = T extends WithArray<infer X> ? X : never;\n"],"mappings":";;;;;;;;;;;AAIO,IAAM,cAAN,cAA0B,aAAa;AAAA,EAC5C,SAAS;AAAA,EACT,YAAY,KAAuB,aAA2B;AAC5D,UAAM,GAAG;AACT,SAAK,mBAAmB,WAAW;AACnC,SAAK,SAAS,EAAE,QAAQ;AAAA,EAC1B;AAAA,EAEQ,mBAAmB,aAA2B;AACpD,QAAI,CAAC,YAAa,OAAM,IAAI,iBAAiB,gCAAgC;AAC7E,QAAI,EAAE,uBAAuB,cAAe,OAAM,IAAI,iBAAiB,gCAAgC;AAAA,EACzG;AACF;","names":[]}

package/lib/chunk-A7I2JEQO.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkVPFIIM2Xjs = require('./chunk-VPFIIM2X.js');
+
+// src/asserts/boolean/index.ts
+function boolean() {
+  return new (0, _chunkVPFIIM2Xjs.BooleanSchema)({ type: ["boolean"], requiredValidations: [] });
+}
+
+
+
+exports.boolean = boolean;
+//# sourceMappingURL=chunk-A7I2JEQO.js.map

package/lib/chunk-A7I2JEQO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-A7I2JEQO.js","../src/asserts/boolean/index.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACQO,SAAS,OAAA,CAAA,EAAyB;AACvC,EAAA,OAAO,IAAI,mCAAA,CAAc,EAAE,IAAA,EAAM,CAAC,SAAS,CAAA,EAAG,mBAAA,EAAqB,CAAC,EAAE,CAAC,CAAA;AACzE;ADNA;AACA;AACE;AACF,0BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-A7I2JEQO.js","sourcesContent":[null,"import { BooleanSchema } from '../../schemas/BooleanSchema';\n\n/**\n * Creates a new schema for validating boolean values.\n *\n * @returns {BooleanSchema} A new instance of `BooleanSchema` for validating booleans.\n *\n * @example\n * const schema = boolean();\n * parseSchema(schema, true); // Validates successfully\n * parseSchema(schema, 'true'); // Throws a validation error\n */\nexport function boolean(): BooleanSchema {\n  return new BooleanSchema({ type: ['boolean'], requiredValidations: [] });\n}\n"]}

package/lib/chunk-AJ4WV5DG.mjs

@@ -0,0 +1,13 @@
+import {
+  CommonSchema
+} from "./chunk-L7HUXYFV.mjs";
+
+// src/asserts/common/index.ts
+function oneOfTypes(valueTypes) {
+  return new CommonSchema({ type: valueTypes, requiredValidations: [] });
+}
+
+export {
+  oneOfTypes
+};
+//# sourceMappingURL=chunk-AJ4WV5DG.mjs.map

package/lib/chunk-AJ4WV5DG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/common/index.ts"],"sourcesContent":["import { CommonSchema, MapMixTypes, PrimitiveType, WithMix } from '../../schemas/CommonSchema';\n\n/**\n * Creates a new schema for validating values that can match any one of the specified primitive types.\n *\n * @template T\n * @param {T} valueTypes - An array of primitive types that the value can match.\n * @returns {WithMix<MapMixTypes<T>>} A new schema for validating values that can match any of the specified types.\n *\n * @example\n * const schema = oneOfTypes(['string', 'number']);\n * parseSchema(schema, 'hello'); // Validates successfully\n * parseSchema(schema, 42); // Validates successfully\n * parseSchema(schema, true); // Throws a validation error\n */\nexport function oneOfTypes<T extends PrimitiveType[]>(valueTypes: T): WithMix<MapMixTypes<T>> {\n  return new CommonSchema({ type: valueTypes, requiredValidations: [] }) as WithMix<MapMixTypes<T>>;\n}\n"],"mappings":";;;;;AAeO,SAAS,WAAsC,YAAwC;AAC5F,SAAO,IAAI,aAAa,EAAE,MAAM,YAAY,qBAAqB,CAAC,EAAE,CAAC;AACvE;","names":[]}

package/lib/chunk-APTTIN2L.js

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5NCJN6D2js = require('./chunk-5NCJN6D2.js');
+
+// src/schemas/CommonSchema.ts
+var CommonSchema = class {
+  
+  constructor(ctx) {
+    this[_chunk5NCJN6D2js.ctxSymbol] = ctx;
+  }
+  /**
+   * @param validators - One or more custom validation functions.
+   * @returns {this} The schema instance with the added custom validation.
+   */
+  custom(...validators) {
+    this[_chunk5NCJN6D2js.ctxSymbol].requiredValidations.push(...validators);
+    return this;
+  }
+  /**
+   * Marks the schema as nullable, allowing the value to be `null`.
+   *
+   * @returns {WithNull<this>} The schema instance marked as nullable.
+   */
+  nullable() {
+    this[_chunk5NCJN6D2js.ctxSymbol].isNullable = true;
+    return this;
+  }
+  /**
+   * Marks the schema as optional, allowing the value to be `undefined`.
+   *
+   * @returns {WithUndefined<this>}} The schema instance marked as optional.
+   */
+  optional() {
+    this[_chunk5NCJN6D2js.ctxSymbol].isOptional = true;
+    return this;
+  }
+};
+
+
+
+exports.CommonSchema = CommonSchema;
+//# sourceMappingURL=chunk-APTTIN2L.js.map

package/lib/chunk-APTTIN2L.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-APTTIN2L.js","../src/schemas/CommonSchema.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACYO,IAAM,aAAA,EAAN,MAAmB;AAAA,EACxB;AAAU,EACV,WAAA,CAAY,GAAA,EAAuB;AACjC,IAAA,IAAA,CAAK,0BAAS,EAAA,EAAI,GAAA;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAA,CAAA,GAAU,UAAA,EAAwC;AAChD,IAAA,IAAA,CAAK,0BAAS,CAAA,CAAE,mBAAA,CAAoB,IAAA,CAAK,GAAG,UAAU,CAAA;AACtD,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAA,CAAA,EAA2B;AACzB,IAAA,IAAA,CAAK,0BAAS,CAAA,CAAE,WAAA,EAAa,IAAA;AAC7B,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAA,CAAA,EAAgC;AAC9B,IAAA,IAAA,CAAK,0BAAS,CAAA,CAAE,WAAA,EAAa,IAAA;AAC7B,IAAA,OAAO,IAAA;AAAA,EACT;AACF,CAAA;ADbA;AACA;AACE;AACF,oCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-APTTIN2L.js","sourcesContent":[null,"import { ctxSymbol } from '../core';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type RequiredValidation = (received: any, pathToError: string) => void;\nexport type ObjectShapeSchemaType = Record<string, CommonSchema>;\n\nexport type PrimitiveType = 'number' | 'string' | 'boolean' | 'undefined' | 'object' | 'function' | 'symbol' | 'bigint';\nexport interface ValidatorContext {\n  type: PrimitiveType[];\n  isNullable?: boolean;\n  isOptional?: boolean;\n  requiredValidations: RequiredValidation[];\n  array?: CommonSchema;\n  object?: ObjectShapeSchemaType;\n}\n\nexport class CommonSchema {\n  [ctxSymbol]: ValidatorContext;\n  constructor(ctx: ValidatorContext) {\n    this[ctxSymbol] = ctx;\n  }\n\n  /**\n   * @param validators - One or more custom validation functions.\n   * @returns {this} The schema instance with the added custom validation.\n   */\n  custom(...validators: RequiredValidation[]): this {\n    this[ctxSymbol].requiredValidations.push(...validators);\n    return this;\n  }\n\n  /**\n   * Marks the schema as nullable, allowing the value to be `null`.\n   *\n   * @returns {WithNull<this>} The schema instance marked as nullable.\n   */\n  nullable(): WithNull<this> {\n    this[ctxSymbol].isNullable = true;\n    return this as WithNull<this>;\n  }\n\n  /**\n   * Marks the schema as optional, allowing the value to be `undefined`.\n   *\n   * @returns {WithUndefined<this>}} The schema instance marked as optional.\n   */\n  optional(): WithUndefined<this> {\n    this[ctxSymbol].isOptional = true;\n    return this as WithUndefined<this>;\n  }\n}\n\nexport type WithNull<T extends CommonSchema> = T & { validation_null: true };\nexport type WithUndefined<T extends CommonSchema> = T & { validation_undefined: true };\n\ntype TypeMapping = {\n  number: number;\n  string: string;\n  boolean: boolean;\n  undefined: undefined;\n  object: object;\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  function: Function;\n  symbol: symbol;\n  bigint: bigint;\n};\n\nexport type WithMix<Y = unknown> = CommonSchema & { validation_mix: Y };\nexport type ExtractFromMix<T> = T extends WithMix<infer X> ? X : never;\n\nexport type MapMixTypes<T extends PrimitiveType[]> = T extends (infer U)[]\n  ? U extends keyof TypeMapping\n    ? TypeMapping[U]\n    : never\n  : never;\n"]}

package/lib/chunk-AXOP6HPJ.js

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk2AP4OQMTjs = require('./chunk-2AP4OQMT.js');
+
+// src/asserts/common/equalTo.ts
+var equalTo = (expected) => (received, pathToError) => {
+  if (expected !== received)
+    _chunk2AP4OQMTjs.throwException.call(void 0, expected, received, pathToError, "The received value is not equal to expected");
+};
+
+
+
+exports.equalTo = equalTo;
+//# sourceMappingURL=chunk-AXOP6HPJ.js.map

package/lib/chunk-AXOP6HPJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-AXOP6HPJ.js","../src/asserts/common/equalTo.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACuBO,IAAM,QAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,WAAA,EAAA,GAAwB;AACzC,EAAA,GAAA,CAAI,SAAA,IAAa,QAAA;AACf,IAAA,6CAAA,QAAe,EAAU,QAAA,EAAU,WAAA,EAAa,6CAA6C,CAAA;AACjG,CAAA;ADvBF;AACA;AACE;AACF,0BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-AXOP6HPJ.js","sourcesContent":[null,"import { throwException } from '../../exceptions';\nimport { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Creates a custom assertion that checks if a value is equal to the expected value.\n *\n * This assertion can be used within a `.custom` method to enforce that a value strictly matches the expected value.\n * It will throw a `ValidationError` if the values are not equal.\n *\n * @param {unknown} expected - The value that the received value is expected to match.\n * @returns {RequiredValidation} A function that takes the received value and the path to the error,\n * and throws a `ValidationError` if the received value does not equal the expected value.\n *\n * @throws {ValidationError} If the received value does not match the expected value.\n *\n * @example\n * import { number, equalTo } from 'bguard';\n *\n * // Define a schema with a custom assertion\n * const schema = number().custom(equalTo(5));\n *\n * // This will pass\n * parseSchema(schema, 5);\n *\n * // This will throw a ValidationError\n * parseSchema(schema, 3);\n */\nexport const equalTo =\n  (expected: unknown): RequiredValidation =>\n  (received: number, pathToError: string) => {\n    if (expected !== received)\n      throwException(expected, received, pathToError, 'The received value is not equal to expected');\n  };\n"]}

package/lib/chunk-BGMR7A6X.mjs

@@ -0,0 +1,13 @@
+import {
+  NumberSchema
+} from "./chunk-63IQFNFO.mjs";
+
+// src/asserts/number/index.ts
+function number() {
+  return new NumberSchema({ type: ["number"], requiredValidations: [] });
+}
+
+export {
+  number
+};
+//# sourceMappingURL=chunk-BGMR7A6X.mjs.map

package/lib/chunk-BGMR7A6X.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/number/index.ts"],"sourcesContent":["import { NumberSchema } from '../../schemas/NumberSchema';\n\n/**\n * Creates a new schema for validating number values.\n *\n * @returns {NumberSchema} A new instance of `NumberSchema` for validating numbers.\n *\n * @example\n * const schema = number();\n * parseSchema(schema, 42); // Validates successfully\n * parseSchema(schema, '42'); // Throws a validation error\n */\nexport function number(): NumberSchema {\n  return new NumberSchema({ type: ['number'], requiredValidations: [] });\n}\n"],"mappings":";;;;;AAYO,SAAS,SAAuB;AACrC,SAAO,IAAI,aAAa,EAAE,MAAM,CAAC,QAAQ,GAAG,qBAAqB,CAAC,EAAE,CAAC;AACvE;","names":[]}

package/lib/chunk-FCFO5J5Y.mjs

@@ -0,0 +1,14 @@
+import {
+  throwException
+} from "./chunk-QJOXKH7A.mjs";
+
+// src/asserts/common/equalTo.ts
+var equalTo = (expected) => (received, pathToError) => {
+  if (expected !== received)
+    throwException(expected, received, pathToError, "The received value is not equal to expected");
+};
+
+export {
+  equalTo
+};
+//# sourceMappingURL=chunk-FCFO5J5Y.mjs.map

package/lib/chunk-FCFO5J5Y.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/common/equalTo.ts"],"sourcesContent":["import { throwException } from '../../exceptions';\nimport { RequiredValidation } from '../../schemas/CommonSchema';\n\n/**\n * Creates a custom assertion that checks if a value is equal to the expected value.\n *\n * This assertion can be used within a `.custom` method to enforce that a value strictly matches the expected value.\n * It will throw a `ValidationError` if the values are not equal.\n *\n * @param {unknown} expected - The value that the received value is expected to match.\n * @returns {RequiredValidation} A function that takes the received value and the path to the error,\n * and throws a `ValidationError` if the received value does not equal the expected value.\n *\n * @throws {ValidationError} If the received value does not match the expected value.\n *\n * @example\n * import { number, equalTo } from 'bguard';\n *\n * // Define a schema with a custom assertion\n * const schema = number().custom(equalTo(5));\n *\n * // This will pass\n * parseSchema(schema, 5);\n *\n * // This will throw a ValidationError\n * parseSchema(schema, 3);\n */\nexport const equalTo =\n  (expected: unknown): RequiredValidation =>\n  (received: number, pathToError: string) => {\n    if (expected !== received)\n      throwException(expected, received, pathToError, 'The received value is not equal to expected');\n  };\n"],"mappings":";;;;;AA2BO,IAAM,UACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,aAAa;AACf,mBAAe,UAAU,UAAU,aAAa,6CAA6C;AACjG;","names":[]}

package/lib/chunk-GEZME6V2.mjs

@@ -0,0 +1,39 @@
+import {
+  CommonSchema
+} from "./chunk-L7HUXYFV.mjs";
+import {
+  throwException
+} from "./chunk-QJOXKH7A.mjs";
+
+// src/schemas/BooleanSchema.ts
+var isBoolean = (expected) => (received, pathToError) => {
+  if (received !== expected) throwException(expected, received, pathToError, `The received value is not ${expected}`);
+};
+var BooleanSchema = class extends CommonSchema {
+  _boolean = 1;
+  /**
+   * Restricts the schema to exactly match the boolean value true and infers the true value as the TypeScript type.
+   *
+   * @returns - The schema instance restricted to the value true, with the true value inferred as the TypeScript type
+   *
+   * @example - boolean().onlyTrue(); // Infers the type true
+   */
+  onlyTrue() {
+    return this.custom(isBoolean(true));
+  }
+  /**
+   * Restricts the schema to exactly match the boolean value false and infers the false value as the TypeScript type.
+   *
+   * @returns - The schema instance restricted to the value false, with the false value inferred as the TypeScript type
+   *
+   * @example - boolean().onlyFalse(); // Infers the type false
+   */
+  onlyFalse() {
+    return this.custom(isBoolean(false));
+  }
+};
+
+export {
+  BooleanSchema
+};
+//# sourceMappingURL=chunk-GEZME6V2.mjs.map