bguard 0.1.0 → 0.1.1

package/lib/asserts/string/lowerCase.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5BVJ6YMHjs = require('../../chunk-5BVJ6YMH.js');
+
+
+var _chunkWK4O3HH4js = require('../../chunk-WK4O3HH4.js');
+
+// src/asserts/string/lowerCase.ts
+var lowerCaseErrorMessage = "The received value is not in lowercase";
+var lowerCaseErrorKey = "s:lowerCase";
+var lowerCase = () => (received, ctx) => {
+  if (received !== received.toLowerCase()) _chunkWK4O3HH4js.guardException.call(void 0, "lower case", received, ctx, lowerCaseErrorKey);
+};
+lowerCase.key = lowerCaseErrorKey;
+lowerCase.message = lowerCaseErrorMessage;
+_chunk5BVJ6YMHjs.setToDefaultLocale.call(void 0, lowerCase);
+
+
+exports.lowerCase = lowerCase;
+//# sourceMappingURL=lowerCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/lowerCase.js","../../../src/asserts/string/lowerCase.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,sBAAA,EAAwB,wCAAA;AAC9B,IAAM,kBAAA,EAAoB,aAAA;AAanB,IAAM,UAAA,EAAY,CAAA,EAAA,GAA0B,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC9F,EAAA,GAAA,CAAI,SAAA,IAAa,QAAA,CAAS,WAAA,CAAY,CAAA,EAAG,6CAAA,YAAe,EAAc,QAAA,EAAU,GAAA,EAAK,iBAAiB,CAAA;AACxG,CAAA;AAEA,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADR5B;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/lowerCase.js","sourcesContent":[null,"import { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { guardException } from '../../exceptions';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst lowerCaseErrorMessage = 'The received value is not in lowercase';\nconst lowerCaseErrorKey = 's:lowerCase';\n\n/**\n * @description Asserts that a string value is in lowercase.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not in lowercase.\n * @example\n * const schema = string().custom(lowerCase());\n * parseOrFail(schema, 'valid');   // Valid\n * parseOrFail(schema, 'Invalid'); // Throws an error: 'The received value is not in lowercase'\n *\n * @translation Error Translation Key = 's:lowerCase'\n */\nexport const lowerCase = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (received !== received.toLowerCase()) guardException('lower case', received, ctx, lowerCaseErrorKey);\n};\n\nlowerCase.key = lowerCaseErrorKey;\nlowerCase.message = lowerCaseErrorMessage;\nsetToDefaultLocale(lowerCase);\n"]}

package/lib/asserts/string/lowerCase.mjs

@@ -0,0 +1,20 @@
+import {
+  setToDefaultLocale
+} from "../../chunk-3HTYHE2X.mjs";
+import {
+  guardException
+} from "../../chunk-7XFLH6R2.mjs";
+
+// src/asserts/string/lowerCase.ts
+var lowerCaseErrorMessage = "The received value is not in lowercase";
+var lowerCaseErrorKey = "s:lowerCase";
+var lowerCase = () => (received, ctx) => {
+  if (received !== received.toLowerCase()) guardException("lower case", received, ctx, lowerCaseErrorKey);
+};
+lowerCase.key = lowerCaseErrorKey;
+lowerCase.message = lowerCaseErrorMessage;
+setToDefaultLocale(lowerCase);
+export {
+  lowerCase
+};
+//# sourceMappingURL=lowerCase.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/asserts/string/lowerCase.ts"],"sourcesContent":["import { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { guardException } from '../../exceptions';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst lowerCaseErrorMessage = 'The received value is not in lowercase';\nconst lowerCaseErrorKey = 's:lowerCase';\n\n/**\n * @description Asserts that a string value is in lowercase.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not in lowercase.\n * @example\n * const schema = string().custom(lowerCase());\n * parseOrFail(schema, 'valid');   // Valid\n * parseOrFail(schema, 'Invalid'); // Throws an error: 'The received value is not in lowercase'\n *\n * @translation Error Translation Key = 's:lowerCase'\n */\nexport const lowerCase = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (received !== received.toLowerCase()) guardException('lower case', received, ctx, lowerCaseErrorKey);\n};\n\nlowerCase.key = lowerCaseErrorKey;\nlowerCase.message = lowerCaseErrorMessage;\nsetToDefaultLocale(lowerCase);\n"],"mappings":";;;;;;;;AAIA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAanB,IAAM,YAAY,MAA0B,CAAC,UAAkB,QAA0B;AAC9F,MAAI,aAAa,SAAS,YAAY,EAAG,gBAAe,cAAc,UAAU,KAAK,iBAAiB;AACxG;AAEA,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}

package/lib/asserts/string/maxLength.d.mts

@@ -3,7 +3,7 @@ import { RequiredValidation } from '../../commonTypes.mjs';
 /**
  * @description Asserts that the length of a string value is not greater than a specified maximum length.
  * @param {number} expected The maximum allowed length for the string.
- * @returns {RequiredValidation} A validation function that takes a received string and a path to the error message.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
  * @throws {ValidationError} if the length of the received value is greater than the expected length.
  * @example
  * const schema = string().custom(maxLength(10));

package/lib/asserts/string/maxLength.d.ts

@@ -3,7 +3,7 @@ import { RequiredValidation } from '../../commonTypes.js';
 /**
  * @description Asserts that the length of a string value is not greater than a specified maximum length.
  * @param {number} expected The maximum allowed length for the string.
- * @returns {RequiredValidation} A validation function that takes a received string and a path to the error message.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
  * @throws {ValidationError} if the length of the received value is greater than the expected length.
  * @example
  * const schema = string().custom(maxLength(10));

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

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/maxLength.js","../../../src/asserts/string/maxLength.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,sBAAA,EAAwB,oDAAA;AAC9B,IAAM,kBAAA,EAAoB,aAAA;AAcnB,IAAM,UAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,QAAA,CAAS,OAAA,EAAS,QAAA,EAAU,6CAAA,QAAe,EAAU,QAAA,EAAU,GAAA,EAAK,qBAAqB,CAAA;AAC/F,CAAA;AAEF,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADX5B;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/maxLength.js","sourcesContent":[null,"import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst maxLengthErrorMessage = 'The received value length is greater than expected';\nconst maxLengthErrorKey = 's:maxLength';\n\n/**\n * @description Asserts that the length of a string value is not greater than a specified maximum length.\n * @param {number} expected The maximum allowed length for the string.\n * @returns {RequiredValidation} A validation function that takes a received string and a path to the error message.\n * @throws {ValidationError} if the length of the received value is greater than the expected length.\n * @example\n * const schema = string().custom(maxLength(10));\n * parseOrFail(schema, 'short');   // Valid\n * parseOrFail(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'\n *\n * @translation Error Translation Key = 's:maxLength'\n */\nexport const maxLength =\n  (expected: number): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (received.length > expected) guardException(expected, received, ctx, maxLengthErrorMessage);\n  };\n\nmaxLength.key = maxLengthErrorKey;\nmaxLength.message = maxLengthErrorMessage;\nsetToDefaultLocale(maxLength);\n"]}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/maxLength.js","../../../src/asserts/string/maxLength.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,sBAAA,EAAwB,oDAAA;AAC9B,IAAM,kBAAA,EAAoB,aAAA;AAcnB,IAAM,UAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,QAAA,CAAS,OAAA,EAAS,QAAA,EAAU,6CAAA,QAAe,EAAU,QAAA,EAAU,GAAA,EAAK,qBAAqB,CAAA;AAC/F,CAAA;AAEF,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADX5B;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/maxLength.js","sourcesContent":[null,"import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst maxLengthErrorMessage = 'The received value length is greater than expected';\nconst maxLengthErrorKey = 's:maxLength';\n\n/**\n * @description Asserts that the length of a string value is not greater than a specified maximum length.\n * @param {number} expected The maximum allowed length for the string.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the length of the received value is greater than the expected length.\n * @example\n * const schema = string().custom(maxLength(10));\n * parseOrFail(schema, 'short');   // Valid\n * parseOrFail(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'\n *\n * @translation Error Translation Key = 's:maxLength'\n */\nexport const maxLength =\n  (expected: number): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (received.length > expected) guardException(expected, received, ctx, maxLengthErrorMessage);\n  };\n\nmaxLength.key = maxLengthErrorKey;\nmaxLength.message = maxLengthErrorMessage;\nsetToDefaultLocale(maxLength);\n"]}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/asserts/string/maxLength.ts"],"sourcesContent":["import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst maxLengthErrorMessage = 'The received value length is greater than expected';\nconst maxLengthErrorKey = 's:maxLength';\n\n/**\n * @description Asserts that the length of a string value is not greater than a specified maximum length.\n * @param {number} expected The maximum allowed length for the string.\n * @returns {RequiredValidation} A validation function that takes a received string and a path to the error message.\n * @throws {ValidationError} if the length of the received value is greater than the expected length.\n * @example\n * const schema = string().custom(maxLength(10));\n * parseOrFail(schema, 'short');   // Valid\n * parseOrFail(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'\n *\n * @translation Error Translation Key = 's:maxLength'\n */\nexport const maxLength =\n  (expected: number): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (received.length > expected) guardException(expected, received, ctx, maxLengthErrorMessage);\n  };\n\nmaxLength.key = maxLengthErrorKey;\nmaxLength.message = maxLengthErrorMessage;\nsetToDefaultLocale(maxLength);\n"],"mappings":";;;;;;;;AAIA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAcnB,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,SAAS,SAAS,SAAU,gBAAe,UAAU,UAAU,KAAK,qBAAqB;AAC/F;AAEF,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}
+{"version":3,"sources":["../../../src/asserts/string/maxLength.ts"],"sourcesContent":["import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst maxLengthErrorMessage = 'The received value length is greater than expected';\nconst maxLengthErrorKey = 's:maxLength';\n\n/**\n * @description Asserts that the length of a string value is not greater than a specified maximum length.\n * @param {number} expected The maximum allowed length for the string.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the length of the received value is greater than the expected length.\n * @example\n * const schema = string().custom(maxLength(10));\n * parseOrFail(schema, 'short');   // Valid\n * parseOrFail(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'\n *\n * @translation Error Translation Key = 's:maxLength'\n */\nexport const maxLength =\n  (expected: number): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (received.length > expected) guardException(expected, received, ctx, maxLengthErrorMessage);\n  };\n\nmaxLength.key = maxLengthErrorKey;\nmaxLength.message = maxLengthErrorMessage;\nsetToDefaultLocale(maxLength);\n"],"mappings":";;;;;;;;AAIA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAcnB,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,SAAS,SAAS,SAAU,gBAAe,UAAU,UAAU,KAAK,qBAAqB;AAC/F;AAEF,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}

package/lib/asserts/string/minLength.d.mts

@@ -3,7 +3,7 @@ import { RequiredValidation } from '../../commonTypes.mjs';
 /**
  * @description Asserts that the length of a string value is not less than a specified minimum length.
  * @param {number} expected The minimum required length for the string.
- * @returns {RequiredValidation} A validation function that takes a received string and a path to the error message.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
  * @throws {ValidationError} if the length of the received value is less than the expected length.
  * @example
  * const schema = string().custom(minLength(5));

package/lib/asserts/string/minLength.d.ts

@@ -3,7 +3,7 @@ import { RequiredValidation } from '../../commonTypes.js';
 /**
  * @description Asserts that the length of a string value is not less than a specified minimum length.
  * @param {number} expected The minimum required length for the string.
- * @returns {RequiredValidation} A validation function that takes a received string and a path to the error message.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
  * @throws {ValidationError} if the length of the received value is less than the expected length.
  * @example
  * const schema = string().custom(minLength(5));

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

@@ -1 +1 @@
-{"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;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,sBAAA,EAAwB,iDAAA;AAC9B,IAAM,kBAAA,EAAoB,aAAA;AAcnB,IAAM,UAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,QAAA,CAAS,OAAA,EAAS,QAAA,EAAU,6CAAA,QAAe,EAAU,QAAA,EAAU,GAAA,EAAK,qBAAqB,CAAA;AAC/F,CAAA;AAEF,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADX5B;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/minLength.js","sourcesContent":[null,"import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst minLengthErrorMessage = 'The received value length is less than expected';\nconst minLengthErrorKey = 's:minLength';\n\n/**\n * @description Asserts that the length of a string value is not less than a specified minimum length.\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.\n * @throws {ValidationError} if the length of the received value is less than the expected length.\n * @example\n * const schema = string().custom(minLength(5));\n * parseOrFail(schema, 'short');    // Throws an error: 'The received value length is less than expected'\n * parseOrFail(schema, 'adequate'); // Valid\n *\n * @translation Error Translation Key = 's:minLength'\n */\nexport const minLength =\n  (expected: number): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (received.length < expected) guardException(expected, received, ctx, minLengthErrorMessage);\n  };\n\nminLength.key = minLengthErrorKey;\nminLength.message = minLengthErrorMessage;\nsetToDefaultLocale(minLength);\n"]}
+{"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;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,sBAAA,EAAwB,iDAAA;AAC9B,IAAM,kBAAA,EAAoB,aAAA;AAcnB,IAAM,UAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,QAAA,CAAS,OAAA,EAAS,QAAA,EAAU,6CAAA,QAAe,EAAU,QAAA,EAAU,GAAA,EAAK,qBAAqB,CAAA;AAC/F,CAAA;AAEF,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADX5B;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/minLength.js","sourcesContent":[null,"import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst minLengthErrorMessage = 'The received value length is less than expected';\nconst minLengthErrorKey = 's:minLength';\n\n/**\n * @description Asserts that the length of a string value is not less than a specified minimum length.\n * @param {number} expected The minimum required length for the string.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the length of the received value is less than the expected length.\n * @example\n * const schema = string().custom(minLength(5));\n * parseOrFail(schema, 'short');    // Throws an error: 'The received value length is less than expected'\n * parseOrFail(schema, 'adequate'); // Valid\n *\n * @translation Error Translation Key = 's:minLength'\n */\nexport const minLength =\n  (expected: number): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (received.length < expected) guardException(expected, received, ctx, minLengthErrorMessage);\n  };\n\nminLength.key = minLengthErrorKey;\nminLength.message = minLengthErrorMessage;\nsetToDefaultLocale(minLength);\n"]}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/asserts/string/minLength.ts"],"sourcesContent":["import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst minLengthErrorMessage = 'The received value length is less than expected';\nconst minLengthErrorKey = 's:minLength';\n\n/**\n * @description Asserts that the length of a string value is not less than a specified minimum length.\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.\n * @throws {ValidationError} if the length of the received value is less than the expected length.\n * @example\n * const schema = string().custom(minLength(5));\n * parseOrFail(schema, 'short');    // Throws an error: 'The received value length is less than expected'\n * parseOrFail(schema, 'adequate'); // Valid\n *\n * @translation Error Translation Key = 's:minLength'\n */\nexport const minLength =\n  (expected: number): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (received.length < expected) guardException(expected, received, ctx, minLengthErrorMessage);\n  };\n\nminLength.key = minLengthErrorKey;\nminLength.message = minLengthErrorMessage;\nsetToDefaultLocale(minLength);\n"],"mappings":";;;;;;;;AAIA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAcnB,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,SAAS,SAAS,SAAU,gBAAe,UAAU,UAAU,KAAK,qBAAqB;AAC/F;AAEF,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}
+{"version":3,"sources":["../../../src/asserts/string/minLength.ts"],"sourcesContent":["import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst minLengthErrorMessage = 'The received value length is less than expected';\nconst minLengthErrorKey = 's:minLength';\n\n/**\n * @description Asserts that the length of a string value is not less than a specified minimum length.\n * @param {number} expected The minimum required length for the string.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the length of the received value is less than the expected length.\n * @example\n * const schema = string().custom(minLength(5));\n * parseOrFail(schema, 'short');    // Throws an error: 'The received value length is less than expected'\n * parseOrFail(schema, 'adequate'); // Valid\n *\n * @translation Error Translation Key = 's:minLength'\n */\nexport const minLength =\n  (expected: number): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (received.length < expected) guardException(expected, received, ctx, minLengthErrorMessage);\n  };\n\nminLength.key = minLengthErrorKey;\nminLength.message = minLengthErrorMessage;\nsetToDefaultLocale(minLength);\n"],"mappings":";;;;;;;;AAIA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAcnB,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,SAAS,SAAS,SAAU,gBAAe,UAAU,UAAU,KAAK,qBAAqB;AAC/F;AAEF,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}

package/lib/asserts/string/regExp.d.mts

@@ -3,7 +3,7 @@ import { RequiredValidation } from '../../commonTypes.mjs';
 /**
  * @description Asserts that a string value matches a specified regular expression pattern.
  * @param {RegExp} expected The regular expression pattern that the string value should match.
- * @returns {RequiredValidation} A validation function that takes a received string and a path to the error message.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
  * @throws {ValidationError} if the received value does not match the expected pattern.
  * @example
  * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern

package/lib/asserts/string/regExp.d.ts

@@ -3,7 +3,7 @@ import { RequiredValidation } from '../../commonTypes.js';
 /**
  * @description Asserts that a string value matches a specified regular expression pattern.
  * @param {RegExp} expected The regular expression pattern that the string value should match.
- * @returns {RequiredValidation} A validation function that takes a received string and a path to the error message.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
  * @throws {ValidationError} if the received value does not match the expected pattern.
  * @example
  * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern

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

@@ -1 +1 @@
-{"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;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,mBAAA,EAAqB,6DAAA;AAC3B,IAAM,eAAA,EAAiB,UAAA;AAchB,IAAM,OAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,CAAC,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA,EAAG,6CAAA,QAAe,EAAU,QAAA,EAAU,GAAA,EAAK,kBAAkB,CAAA;AAC1F,CAAA;AAEF,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADXzB;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/regExp.js","sourcesContent":[null,"import { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { guardException } from '../../exceptions';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst regExpErrorMessage = 'The received value does not match the required text pattern';\nconst regExpErrorKey = 's:regExp';\n\n/**\n * @description Asserts that a string value matches a specified regular expression pattern.\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.\n * @throws {ValidationError} if the received value does not match the expected pattern.\n * @example\n * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern\n * parseOrFail(schema, 'valid123');   // Valid\n * parseOrFail(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'\n *\n * @translation Error Translation Key = 's:regExp'\n */\nexport const regExp =\n  (expected: RegExp): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!expected.test(received)) guardException(expected, received, ctx, regExpErrorMessage);\n  };\n\nregExp.key = regExpErrorKey;\nregExp.message = regExpErrorMessage;\nsetToDefaultLocale(regExp);\n"]}
+{"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;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,mBAAA,EAAqB,6DAAA;AAC3B,IAAM,eAAA,EAAiB,UAAA;AAchB,IAAM,OAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,CAAC,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA,EAAG,6CAAA,QAAe,EAAU,QAAA,EAAU,GAAA,EAAK,kBAAkB,CAAA;AAC1F,CAAA;AAEF,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADXzB;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/regExp.js","sourcesContent":[null,"import { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { guardException } from '../../exceptions';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst regExpErrorMessage = 'The received value does not match the required text pattern';\nconst regExpErrorKey = 's:regExp';\n\n/**\n * @description Asserts that a string value matches a specified regular expression pattern.\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 an exception context.\n * @throws {ValidationError} if the received value does not match the expected pattern.\n * @example\n * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern\n * parseOrFail(schema, 'valid123');   // Valid\n * parseOrFail(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'\n *\n * @translation Error Translation Key = 's:regExp'\n */\nexport const regExp =\n  (expected: RegExp): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!expected.test(received)) guardException(expected, received, ctx, regExpErrorMessage);\n  };\n\nregExp.key = regExpErrorKey;\nregExp.message = regExpErrorMessage;\nsetToDefaultLocale(regExp);\n"]}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/asserts/string/regExp.ts"],"sourcesContent":["import { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { guardException } from '../../exceptions';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst regExpErrorMessage = 'The received value does not match the required text pattern';\nconst regExpErrorKey = 's:regExp';\n\n/**\n * @description Asserts that a string value matches a specified regular expression pattern.\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.\n * @throws {ValidationError} if the received value does not match the expected pattern.\n * @example\n * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern\n * parseOrFail(schema, 'valid123');   // Valid\n * parseOrFail(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'\n *\n * @translation Error Translation Key = 's:regExp'\n */\nexport const regExp =\n  (expected: RegExp): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!expected.test(received)) guardException(expected, received, ctx, regExpErrorMessage);\n  };\n\nregExp.key = regExpErrorKey;\nregExp.message = regExpErrorMessage;\nsetToDefaultLocale(regExp);\n"],"mappings":";;;;;;;;AAIA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AAchB,IAAM,SACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,KAAK,QAAQ,EAAG,gBAAe,UAAU,UAAU,KAAK,kBAAkB;AAC1F;AAEF,OAAO,MAAM;AACb,OAAO,UAAU;AACjB,mBAAmB,MAAM;","names":[]}
+{"version":3,"sources":["../../../src/asserts/string/regExp.ts"],"sourcesContent":["import { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { guardException } from '../../exceptions';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst regExpErrorMessage = 'The received value does not match the required text pattern';\nconst regExpErrorKey = 's:regExp';\n\n/**\n * @description Asserts that a string value matches a specified regular expression pattern.\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 an exception context.\n * @throws {ValidationError} if the received value does not match the expected pattern.\n * @example\n * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern\n * parseOrFail(schema, 'valid123');   // Valid\n * parseOrFail(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'\n *\n * @translation Error Translation Key = 's:regExp'\n */\nexport const regExp =\n  (expected: RegExp): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!expected.test(received)) guardException(expected, received, ctx, regExpErrorMessage);\n  };\n\nregExp.key = regExpErrorKey;\nregExp.message = regExpErrorMessage;\nsetToDefaultLocale(regExp);\n"],"mappings":";;;;;;;;AAIA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AAchB,IAAM,SACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,KAAK,QAAQ,EAAG,gBAAe,UAAU,UAAU,KAAK,kBAAkB;AAC1F;AAEF,OAAO,MAAM;AACb,OAAO,UAAU;AACjB,mBAAmB,MAAM;","names":[]}

package/lib/asserts/string/startsWith.d.mts

@@ -0,0 +1,21 @@
+import { RequiredValidation } from '../../commonTypes.mjs';
+
+/**
+ * @description Asserts that a string value starts with a specified substring.
+ * @param {string} substring The substring that the string value must start with.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value does not start with the required substring.
+ * @example
+ * const schema = string().custom(startsWith('foo'));
+ * parseOrFail(schema, 'foobar'); // Valid
+ * parseOrFail(schema, 'barfoo'); // Throws an error: 'The received value does not start with the required substring'
+ *
+ * @translation Error Translation Key = 's:startsWith'
+ */
+declare const startsWith: {
+    (substring: string): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { startsWith };

package/lib/asserts/string/startsWith.d.ts

@@ -0,0 +1,21 @@
+import { RequiredValidation } from '../../commonTypes.js';
+
+/**
+ * @description Asserts that a string value starts with a specified substring.
+ * @param {string} substring The substring that the string value must start with.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value does not start with the required substring.
+ * @example
+ * const schema = string().custom(startsWith('foo'));
+ * parseOrFail(schema, 'foobar'); // Valid
+ * parseOrFail(schema, 'barfoo'); // Throws an error: 'The received value does not start with the required substring'
+ *
+ * @translation Error Translation Key = 's:startsWith'
+ */
+declare const startsWith: {
+    (substring: string): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { startsWith };

package/lib/asserts/string/startsWith.js

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5BVJ6YMHjs = require('../../chunk-5BVJ6YMH.js');
+
+
+var _chunkWK4O3HH4js = require('../../chunk-WK4O3HH4.js');
+
+// src/asserts/string/startsWith.ts
+var startsWithErrorMessage = "The received value does not start with the required substring";
+var startsWithErrorKey = "s:startsWith";
+var startsWith = (substring) => (received, ctx) => {
+  if (!received.startsWith(substring)) {
+    _chunkWK4O3HH4js.guardException.call(void 0, `starts with '${substring}'`, received, ctx, startsWithErrorKey);
+  }
+};
+startsWith.key = startsWithErrorKey;
+startsWith.message = startsWithErrorMessage;
+_chunk5BVJ6YMHjs.setToDefaultLocale.call(void 0, startsWith);
+
+
+exports.startsWith = startsWith;
+//# sourceMappingURL=startsWith.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/startsWith.js","../../../src/asserts/string/startsWith.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,uBAAA,EAAyB,+DAAA;AAC/B,IAAM,mBAAA,EAAqB,cAAA;AAcpB,IAAM,WAAA,EACX,CAAC,SAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,CAAC,QAAA,CAAS,UAAA,CAAW,SAAS,CAAA,EAAG;AACnC,IAAA,6CAAA,CAAe,aAAA,EAAgB,SAAS,CAAA,CAAA,CAAA,EAAK,QAAA,EAAU,GAAA,EAAK,kBAAkB,CAAA;AAAA,EAChF;AACF,CAAA;AAEF,UAAA,CAAW,IAAA,EAAM,kBAAA;AACjB,UAAA,CAAW,QAAA,EAAU,sBAAA;AACrB,iDAAA,UAA6B,CAAA;ADX7B;AACE;AACF,gCAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/startsWith.js","sourcesContent":[null,"import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst startsWithErrorMessage = 'The received value does not start with the required substring';\nconst startsWithErrorKey = 's:startsWith';\n\n/**\n * @description Asserts that a string value starts with a specified substring.\n * @param {string} substring The substring that the string value must start with.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not start with the required substring.\n * @example\n * const schema = string().custom(startsWith('foo'));\n * parseOrFail(schema, 'foobar'); // Valid\n * parseOrFail(schema, 'barfoo'); // Throws an error: 'The received value does not start with the required substring'\n *\n * @translation Error Translation Key = 's:startsWith'\n */\nexport const startsWith =\n  (substring: string): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!received.startsWith(substring)) {\n      guardException(`starts with '${substring}'`, received, ctx, startsWithErrorKey);\n    }\n  };\n\nstartsWith.key = startsWithErrorKey;\nstartsWith.message = startsWithErrorMessage;\nsetToDefaultLocale(startsWith);\n"]}

package/lib/asserts/string/startsWith.mjs

@@ -0,0 +1,22 @@
+import {
+  setToDefaultLocale
+} from "../../chunk-3HTYHE2X.mjs";
+import {
+  guardException
+} from "../../chunk-7XFLH6R2.mjs";
+
+// src/asserts/string/startsWith.ts
+var startsWithErrorMessage = "The received value does not start with the required substring";
+var startsWithErrorKey = "s:startsWith";
+var startsWith = (substring) => (received, ctx) => {
+  if (!received.startsWith(substring)) {
+    guardException(`starts with '${substring}'`, received, ctx, startsWithErrorKey);
+  }
+};
+startsWith.key = startsWithErrorKey;
+startsWith.message = startsWithErrorMessage;
+setToDefaultLocale(startsWith);
+export {
+  startsWith
+};
+//# sourceMappingURL=startsWith.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/asserts/string/startsWith.ts"],"sourcesContent":["import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst startsWithErrorMessage = 'The received value does not start with the required substring';\nconst startsWithErrorKey = 's:startsWith';\n\n/**\n * @description Asserts that a string value starts with a specified substring.\n * @param {string} substring The substring that the string value must start with.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not start with the required substring.\n * @example\n * const schema = string().custom(startsWith('foo'));\n * parseOrFail(schema, 'foobar'); // Valid\n * parseOrFail(schema, 'barfoo'); // Throws an error: 'The received value does not start with the required substring'\n *\n * @translation Error Translation Key = 's:startsWith'\n */\nexport const startsWith =\n  (substring: string): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!received.startsWith(substring)) {\n      guardException(`starts with '${substring}'`, received, ctx, startsWithErrorKey);\n    }\n  };\n\nstartsWith.key = startsWithErrorKey;\nstartsWith.message = startsWithErrorMessage;\nsetToDefaultLocale(startsWith);\n"],"mappings":";;;;;;;;AAIA,IAAM,yBAAyB;AAC/B,IAAM,qBAAqB;AAcpB,IAAM,aACX,CAAC,cACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,WAAW,SAAS,GAAG;AACnC,mBAAe,gBAAgB,SAAS,KAAK,UAAU,KAAK,kBAAkB;AAAA,EAChF;AACF;AAEF,WAAW,MAAM;AACjB,WAAW,UAAU;AACrB,mBAAmB,UAAU;","names":[]}

package/lib/asserts/string/upperCase.d.mts

@@ -0,0 +1,21 @@
+import { RequiredValidation } from '../../commonTypes.mjs';
+
+/**
+ * @description Asserts that a string value is entirely in uppercase.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value is not in uppercase.
+ * @example
+ * const schema = string().custom(upperCase());
+ * parseOrFail(schema, 'VALID');    // Valid
+ * parseOrFail(schema, 'INVALID');  // Throws an error: 'The received value is not in uppercase'
+ * parseOrFail(schema, 'Valid');    // Throws an error: 'The received value is not in uppercase'
+ *
+ * @translation Error Translation Key = 's:upperCase'
+ */
+declare const upperCase: {
+    (): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { upperCase };

package/lib/asserts/string/upperCase.d.ts

@@ -0,0 +1,21 @@
+import { RequiredValidation } from '../../commonTypes.js';
+
+/**
+ * @description Asserts that a string value is entirely in uppercase.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value is not in uppercase.
+ * @example
+ * const schema = string().custom(upperCase());
+ * parseOrFail(schema, 'VALID');    // Valid
+ * parseOrFail(schema, 'INVALID');  // Throws an error: 'The received value is not in uppercase'
+ * parseOrFail(schema, 'Valid');    // Throws an error: 'The received value is not in uppercase'
+ *
+ * @translation Error Translation Key = 's:upperCase'
+ */
+declare const upperCase: {
+    (): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { upperCase };

package/lib/asserts/string/upperCase.js

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5BVJ6YMHjs = require('../../chunk-5BVJ6YMH.js');
+
+
+var _chunkWK4O3HH4js = require('../../chunk-WK4O3HH4.js');
+
+// src/asserts/string/upperCase.ts
+var upperCaseErrorMessage = "The received value is not in uppercase";
+var upperCaseErrorKey = "s:upperCase";
+var upperCase = () => (received, ctx) => {
+  if (received !== received.toUpperCase()) {
+    _chunkWK4O3HH4js.guardException.call(void 0, "upper case", received, ctx, upperCaseErrorKey);
+  }
+};
+upperCase.key = upperCaseErrorKey;
+upperCase.message = upperCaseErrorMessage;
+_chunk5BVJ6YMHjs.setToDefaultLocale.call(void 0, upperCase);
+
+
+exports.upperCase = upperCase;
+//# sourceMappingURL=upperCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/upperCase.js","../../../src/asserts/string/upperCase.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,sBAAA,EAAwB,wCAAA;AAC9B,IAAM,kBAAA,EAAoB,aAAA;AAcnB,IAAM,UAAA,EAAY,CAAA,EAAA,GAA0B,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC9F,EAAA,GAAA,CAAI,SAAA,IAAa,QAAA,CAAS,WAAA,CAAY,CAAA,EAAG;AACvC,IAAA,6CAAA,YAAe,EAAc,QAAA,EAAU,GAAA,EAAK,iBAAiB,CAAA;AAAA,EAC/D;AACF,CAAA;AAEA,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADT5B;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/upperCase.js","sourcesContent":[null,"import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst upperCaseErrorMessage = 'The received value is not in uppercase';\nconst upperCaseErrorKey = 's:upperCase';\n\n/**\n * @description Asserts that a string value is entirely in uppercase.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not in uppercase.\n * @example\n * const schema = string().custom(upperCase());\n * parseOrFail(schema, 'VALID');    // Valid\n * parseOrFail(schema, 'INVALID');  // Throws an error: 'The received value is not in uppercase'\n * parseOrFail(schema, 'Valid');    // Throws an error: 'The received value is not in uppercase'\n *\n * @translation Error Translation Key = 's:upperCase'\n */\nexport const upperCase = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (received !== received.toUpperCase()) {\n    guardException('upper case', received, ctx, upperCaseErrorKey);\n  }\n};\n\nupperCase.key = upperCaseErrorKey;\nupperCase.message = upperCaseErrorMessage;\nsetToDefaultLocale(upperCase);\n"]}

package/lib/asserts/string/upperCase.mjs

@@ -0,0 +1,22 @@
+import {
+  setToDefaultLocale
+} from "../../chunk-3HTYHE2X.mjs";
+import {
+  guardException
+} from "../../chunk-7XFLH6R2.mjs";
+
+// src/asserts/string/upperCase.ts
+var upperCaseErrorMessage = "The received value is not in uppercase";
+var upperCaseErrorKey = "s:upperCase";
+var upperCase = () => (received, ctx) => {
+  if (received !== received.toUpperCase()) {
+    guardException("upper case", received, ctx, upperCaseErrorKey);
+  }
+};
+upperCase.key = upperCaseErrorKey;
+upperCase.message = upperCaseErrorMessage;
+setToDefaultLocale(upperCase);
+export {
+  upperCase
+};
+//# sourceMappingURL=upperCase.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/asserts/string/upperCase.ts"],"sourcesContent":["import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst upperCaseErrorMessage = 'The received value is not in uppercase';\nconst upperCaseErrorKey = 's:upperCase';\n\n/**\n * @description Asserts that a string value is entirely in uppercase.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not in uppercase.\n * @example\n * const schema = string().custom(upperCase());\n * parseOrFail(schema, 'VALID');    // Valid\n * parseOrFail(schema, 'INVALID');  // Throws an error: 'The received value is not in uppercase'\n * parseOrFail(schema, 'Valid');    // Throws an error: 'The received value is not in uppercase'\n *\n * @translation Error Translation Key = 's:upperCase'\n */\nexport const upperCase = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (received !== received.toUpperCase()) {\n    guardException('upper case', received, ctx, upperCaseErrorKey);\n  }\n};\n\nupperCase.key = upperCaseErrorKey;\nupperCase.message = upperCaseErrorMessage;\nsetToDefaultLocale(upperCase);\n"],"mappings":";;;;;;;;AAIA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAcnB,IAAM,YAAY,MAA0B,CAAC,UAAkB,QAA0B;AAC9F,MAAI,aAAa,SAAS,YAAY,GAAG;AACvC,mBAAe,cAAc,UAAU,KAAK,iBAAiB;AAAA,EAC/D;AACF;AAEA,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}

package/lib/asserts/string/uuid.d.mts

@@ -0,0 +1,20 @@
+import { RequiredValidation } from '../../commonTypes.mjs';
+
+/**
+ * @description Asserts that a string value matches the UUID format.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value is not a valid UUID.
+ * @example
+ * const schema = string().custom(uuid());
+ * parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Valid
+ * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID'
+ *
+ * @translation Error Translation Key = 's:uuid'
+ */
+declare const uuid: {
+    (): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { uuid };

package/lib/asserts/string/uuid.d.ts

@@ -0,0 +1,20 @@
+import { RequiredValidation } from '../../commonTypes.js';
+
+/**
+ * @description Asserts that a string value matches the UUID format.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value is not a valid UUID.
+ * @example
+ * const schema = string().custom(uuid());
+ * parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Valid
+ * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID'
+ *
+ * @translation Error Translation Key = 's:uuid'
+ */
+declare const uuid: {
+    (): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { uuid };

package/lib/asserts/string/uuid.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5BVJ6YMHjs = require('../../chunk-5BVJ6YMH.js');
+
+
+var _chunkWK4O3HH4js = require('../../chunk-WK4O3HH4.js');
+
+// src/asserts/string/uuid.ts
+var uuidErrorMessage = "The received value is not a valid UUID";
+var uuidErrorKey = "s:uuid";
+var uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var uuid = () => (received, ctx) => {
+  if (!uuidPattern.test(received)) {
+    _chunkWK4O3HH4js.guardException.call(void 0, "uuid", received, ctx, uuidErrorKey);
+  }
+};
+uuid.key = uuidErrorKey;
+uuid.message = uuidErrorMessage;
+_chunk5BVJ6YMHjs.setToDefaultLocale.call(void 0, uuid);
+
+
+exports.uuid = uuid;
+//# sourceMappingURL=uuid.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/uuid.js","../../../src/asserts/string/uuid.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,iBAAA,EAAmB,wCAAA;AACzB,IAAM,aAAA,EAAe,QAAA;AAErB,IAAM,YAAA,EAAc,iEAAA;AAab,IAAM,KAAA,EAAO,CAAA,EAAA,GAA0B,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AACzF,EAAA,GAAA,CAAI,CAAC,WAAA,CAAY,IAAA,CAAK,QAAQ,CAAA,EAAG;AAC/B,IAAA,6CAAA,MAAe,EAAQ,QAAA,EAAU,GAAA,EAAK,YAAY,CAAA;AAAA,EACpD;AACF,CAAA;AAEA,IAAA,CAAK,IAAA,EAAM,YAAA;AACX,IAAA,CAAK,QAAA,EAAU,gBAAA;AACf,iDAAA,IAAuB,CAAA;ADTvB;AACE;AACF,oBAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/uuid.js","sourcesContent":[null,"import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidErrorMessage = 'The received value is not a valid UUID';\nconst uuidErrorKey = 's:uuid';\n\nconst uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n/**\n * @description Asserts that a string value matches the UUID format.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not a valid UUID.\n * @example\n * const schema = string().custom(uuid());\n * parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Valid\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID'\n *\n * @translation Error Translation Key = 's:uuid'\n */\nexport const uuid = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!uuidPattern.test(received)) {\n    guardException('uuid', received, ctx, uuidErrorKey);\n  }\n};\n\nuuid.key = uuidErrorKey;\nuuid.message = uuidErrorMessage;\nsetToDefaultLocale(uuid);\n"]}

package/lib/asserts/string/uuid.mjs

@@ -0,0 +1,23 @@
+import {
+  setToDefaultLocale
+} from "../../chunk-3HTYHE2X.mjs";
+import {
+  guardException
+} from "../../chunk-7XFLH6R2.mjs";
+
+// src/asserts/string/uuid.ts
+var uuidErrorMessage = "The received value is not a valid UUID";
+var uuidErrorKey = "s:uuid";
+var uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var uuid = () => (received, ctx) => {
+  if (!uuidPattern.test(received)) {
+    guardException("uuid", received, ctx, uuidErrorKey);
+  }
+};
+uuid.key = uuidErrorKey;
+uuid.message = uuidErrorMessage;
+setToDefaultLocale(uuid);
+export {
+  uuid
+};
+//# sourceMappingURL=uuid.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/asserts/string/uuid.ts"],"sourcesContent":["import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidErrorMessage = 'The received value is not a valid UUID';\nconst uuidErrorKey = 's:uuid';\n\nconst uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n/**\n * @description Asserts that a string value matches the UUID format.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not a valid UUID.\n * @example\n * const schema = string().custom(uuid());\n * parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Valid\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID'\n *\n * @translation Error Translation Key = 's:uuid'\n */\nexport const uuid = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!uuidPattern.test(received)) {\n    guardException('uuid', received, ctx, uuidErrorKey);\n  }\n};\n\nuuid.key = uuidErrorKey;\nuuid.message = uuidErrorMessage;\nsetToDefaultLocale(uuid);\n"],"mappings":";;;;;;;;AAIA,IAAM,mBAAmB;AACzB,IAAM,eAAe;AAErB,IAAM,cAAc;AAab,IAAM,OAAO,MAA0B,CAAC,UAAkB,QAA0B;AACzF,MAAI,CAAC,YAAY,KAAK,QAAQ,GAAG;AAC/B,mBAAe,QAAQ,UAAU,KAAK,YAAY;AAAA,EACpD;AACF;AAEA,KAAK,MAAM;AACX,KAAK,UAAU;AACf,mBAAmB,IAAI;","names":[]}

package/lib/asserts/string/uuidV1.d.mts

@@ -0,0 +1,21 @@
+import { RequiredValidation } from '../../commonTypes.mjs';
+
+/**
+ * @description Asserts that a string value matches the UUID v1 format.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value is not a valid UUID v1.
+ * @example
+ * const schema = string().custom(uuidV1());
+ * parseOrFail(schema, '550e8400-e29b-11d4-a716-446655440000'); // Valid
+ * parseOrFail(schema, '550e8400-e29b-21d4-a716-446655440000'); // Throws an error: 'The received value is not a valid UUID v1'
+ * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v1'
+ *
+ * @translation Error Translation Key = 's:uuidV1'
+ */
+declare const uuidV1: {
+    (): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { uuidV1 };

package/lib/asserts/string/uuidV1.d.ts

@@ -0,0 +1,21 @@
+import { RequiredValidation } from '../../commonTypes.js';
+
+/**
+ * @description Asserts that a string value matches the UUID v1 format.
+ * @returns {RequiredValidation} A validation function that takes a received string and an exception context.
+ * @throws {ValidationError} if the received value is not a valid UUID v1.
+ * @example
+ * const schema = string().custom(uuidV1());
+ * parseOrFail(schema, '550e8400-e29b-11d4-a716-446655440000'); // Valid
+ * parseOrFail(schema, '550e8400-e29b-21d4-a716-446655440000'); // Throws an error: 'The received value is not a valid UUID v1'
+ * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v1'
+ *
+ * @translation Error Translation Key = 's:uuidV1'
+ */
+declare const uuidV1: {
+    (): RequiredValidation;
+    key: string;
+    message: string;
+};
+
+export { uuidV1 };

package/lib/asserts/string/uuidV1.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5BVJ6YMHjs = require('../../chunk-5BVJ6YMH.js');
+
+
+var _chunkWK4O3HH4js = require('../../chunk-WK4O3HH4.js');
+
+// src/asserts/string/uuidV1.ts
+var uuidV1ErrorMessage = "The received value is not a valid UUID v1";
+var uuidV1ErrorKey = "s:uuidV1";
+var uuidV1Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var uuidV1 = () => (received, ctx) => {
+  if (!uuidV1Pattern.test(received)) {
+    _chunkWK4O3HH4js.guardException.call(void 0, "uuid v1", received, ctx, uuidV1ErrorKey);
+  }
+};
+uuidV1.key = uuidV1ErrorKey;
+uuidV1.message = uuidV1ErrorMessage;
+_chunk5BVJ6YMHjs.setToDefaultLocale.call(void 0, uuidV1);
+
+
+exports.uuidV1 = uuidV1;
+//# sourceMappingURL=uuidV1.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/asserts/string/uuidV1.js","../../../src/asserts/string/uuidV1.ts"],"names":[],"mappings":"AAAA;AACE;AACF,0DAAgC;AAChC;AACE;AACF,0DAAgC;AAChC;AACA;ACHA,IAAM,mBAAA,EAAqB,2CAAA;AAC3B,IAAM,eAAA,EAAiB,UAAA;AAEvB,IAAM,cAAA,EAAgB,wEAAA;AAcf,IAAM,OAAA,EAAS,CAAA,EAAA,GAA0B,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3F,EAAA,GAAA,CAAI,CAAC,aAAA,CAAc,IAAA,CAAK,QAAQ,CAAA,EAAG;AACjC,IAAA,6CAAA,SAAe,EAAW,QAAA,EAAU,GAAA,EAAK,cAAc,CAAA;AAAA,EACzD;AACF,CAAA;AAEA,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADVzB;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/uuidV1.js","sourcesContent":[null,"import { guardException } from '../../exceptions';\nimport { ExceptionContext, RequiredValidation } from '../../commonTypes';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV1ErrorMessage = 'The received value is not a valid UUID v1';\nconst uuidV1ErrorKey = 's:uuidV1';\n\nconst uuidV1Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n\n/**\n * @description Asserts that a string value matches the UUID v1 format.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not a valid UUID v1.\n * @example\n * const schema = string().custom(uuidV1());\n * parseOrFail(schema, '550e8400-e29b-11d4-a716-446655440000'); // Valid\n * parseOrFail(schema, '550e8400-e29b-21d4-a716-446655440000'); // Throws an error: 'The received value is not a valid UUID v1'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v1'\n *\n * @translation Error Translation Key = 's:uuidV1'\n */\nexport const uuidV1 = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV1Pattern.test(received)) {\n    guardException('uuid v1', received, ctx, uuidV1ErrorKey);\n  }\n};\n\nuuidV1.key = uuidV1ErrorKey;\nuuidV1.message = uuidV1ErrorMessage;\nsetToDefaultLocale(uuidV1);\n"]}

package/lib/asserts/string/uuidV1.mjs

@@ -0,0 +1,23 @@
+import {
+  setToDefaultLocale
+} from "../../chunk-3HTYHE2X.mjs";
+import {
+  guardException
+} from "../../chunk-7XFLH6R2.mjs";
+
+// src/asserts/string/uuidV1.ts
+var uuidV1ErrorMessage = "The received value is not a valid UUID v1";
+var uuidV1ErrorKey = "s:uuidV1";
+var uuidV1Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var uuidV1 = () => (received, ctx) => {
+  if (!uuidV1Pattern.test(received)) {
+    guardException("uuid v1", received, ctx, uuidV1ErrorKey);
+  }
+};
+uuidV1.key = uuidV1ErrorKey;
+uuidV1.message = uuidV1ErrorMessage;
+setToDefaultLocale(uuidV1);
+export {
+  uuidV1
+};
+//# sourceMappingURL=uuidV1.mjs.map