bguard 0.0.9 → 0.1.1

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

@@ -1,16 +1,21 @@
-import { R as RequiredValidation } from '../../CommonSchema-BIe85W_A.mjs';
+import { RequiredValidation } from '../../commonTypes.mjs';
 
 /**
- * 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. Throws an error if the length of the received value is greater than the expected length.
- *
+ * @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 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));
- * parseSchema(schema, 'short');   // Valid
- * parseSchema(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'
+ * parseOrFail(schema, 'short');   // Valid
+ * parseOrFail(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'
+ *
+ * @translation Error Translation Key = 's:maxLength'
  */
-declare const maxLength: (expected: number) => RequiredValidation;
+declare const maxLength: {
+    (expected: number): RequiredValidation;
+    key: string;
+    message: string;
+};
 
 export { maxLength };

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

@@ -1,16 +1,21 @@
-import { R as RequiredValidation } from '../../CommonSchema-BIe85W_A.js';
+import { RequiredValidation } from '../../commonTypes.js';
 
 /**
- * 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. Throws an error if the length of the received value is greater than the expected length.
- *
+ * @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 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));
- * parseSchema(schema, 'short');   // Valid
- * parseSchema(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'
+ * parseOrFail(schema, 'short');   // Valid
+ * parseOrFail(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'
+ *
+ * @translation Error Translation Key = 's:maxLength'
  */
-declare const maxLength: (expected: number) => RequiredValidation;
+declare const maxLength: {
+    (expected: number): RequiredValidation;
+    key: string;
+    message: string;
+};
 
 export { maxLength };

package/lib/asserts/string/maxLength.js

@@ -1,12 +1,19 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk2AP4OQMTjs = require('../../chunk-2AP4OQMT.js');
+var _chunk5BVJ6YMHjs = require('../../chunk-5BVJ6YMH.js');
+
+
+var _chunkWK4O3HH4js = require('../../chunk-WK4O3HH4.js');
 
 // src/asserts/string/maxLength.ts
-var maxLength = (expected) => (received, pathToError) => {
-  if (received.length > expected)
-    _chunk2AP4OQMTjs.throwException.call(void 0, expected, received, pathToError, "The received value length is greater than expected");
+var maxLengthErrorMessage = "The received value length is greater than expected";
+var maxLengthErrorKey = "s:maxLength";
+var maxLength = (expected) => (received, ctx) => {
+  if (received.length > expected) _chunkWK4O3HH4js.guardException.call(void 0, expected, received, ctx, maxLengthErrorMessage);
 };
+maxLength.key = maxLengthErrorKey;
+maxLength.message = maxLengthErrorMessage;
+_chunk5BVJ6YMHjs.setToDefaultLocale.call(void 0, maxLength);
 
 
 exports.maxLength = maxLength;

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;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,oDAAoD,CAAA;AACxG,CAAA;ADVF;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/asserts/string/maxLength.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 greater than a specified maximum length.\n *\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. Throws an error if the length of the received value is greater than the expected length.\n *\n * @example\n * const schema = string().custom(maxLength(10));\n * parseSchema(schema, 'short');   // Valid\n * parseSchema(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'\n */\nexport const maxLength =\n  (expected: number): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (received.length > expected)\n      throwException(expected, received, pathToError, 'The received value length is greater than expected');\n  };\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

@@ -1,12 +1,19 @@
 import {
-  throwException
-} from "../../chunk-QJOXKH7A.mjs";
+  setToDefaultLocale
+} from "../../chunk-3HTYHE2X.mjs";
+import {
+  guardException
+} from "../../chunk-7XFLH6R2.mjs";
 
 // src/asserts/string/maxLength.ts
-var maxLength = (expected) => (received, pathToError) => {
-  if (received.length > expected)
-    throwException(expected, received, pathToError, "The received value length is greater than expected");
+var maxLengthErrorMessage = "The received value length is greater than expected";
+var maxLengthErrorKey = "s:maxLength";
+var maxLength = (expected) => (received, ctx) => {
+  if (received.length > expected) guardException(expected, received, ctx, maxLengthErrorMessage);
 };
+maxLength.key = maxLengthErrorKey;
+maxLength.message = maxLengthErrorMessage;
+setToDefaultLocale(maxLength);
 export {
   maxLength
 };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/asserts/string/maxLength.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 greater than a specified maximum length.\n *\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. Throws an error if the length of the received value is greater than the expected length.\n *\n * @example\n * const schema = string().custom(maxLength(10));\n * parseSchema(schema, 'short');   // Valid\n * parseSchema(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'\n */\nexport const maxLength =\n  (expected: number): RequiredValidation =>\n  (received: string, pathToError: string) => {\n    if (received.length > expected)\n      throwException(expected, received, pathToError, 'The received value length is greater than expected');\n  };\n"],"mappings":";;;;;AAcO,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,gBAAwB;AACzC,MAAI,SAAS,SAAS;AACpB,mBAAe,UAAU,UAAU,aAAa,oDAAoD;AACxG;","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

@@ -1,16 +1,21 @@
-import { R as RequiredValidation } from '../../CommonSchema-BIe85W_A.mjs';
+import { RequiredValidation } from '../../commonTypes.mjs';
 
 /**
- * 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. Throws an error if the length of the received value is less than the expected length.
- *
+ * @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 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));
- * parseSchema(schema, 'short');   // Throws an error: 'The received value length is less than expected'
- * parseSchema(schema, 'adequate'); // Valid
+ * parseOrFail(schema, 'short');    // Throws an error: 'The received value length is less than expected'
+ * parseOrFail(schema, 'adequate'); // Valid
+ *
+ * @translation Error Translation Key = 's:minLength'
  */
-declare const minLength: (expected: number) => RequiredValidation;
+declare const minLength: {
+    (expected: number): RequiredValidation;
+    key: string;
+    message: string;
+};
 
 export { minLength };

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

@@ -1,16 +1,21 @@
-import { R as RequiredValidation } from '../../CommonSchema-BIe85W_A.js';
+import { RequiredValidation } from '../../commonTypes.js';
 
 /**
- * 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. Throws an error if the length of the received value is less than the expected length.
- *
+ * @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 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));
- * parseSchema(schema, 'short');   // Throws an error: 'The received value length is less than expected'
- * parseSchema(schema, 'adequate'); // Valid
+ * parseOrFail(schema, 'short');    // Throws an error: 'The received value length is less than expected'
+ * parseOrFail(schema, 'adequate'); // Valid
+ *
+ * @translation Error Translation Key = 's:minLength'
  */
-declare const minLength: (expected: number) => RequiredValidation;
+declare const minLength: {
+    (expected: number): RequiredValidation;
+    key: string;
+    message: string;
+};
 
 export { minLength };

package/lib/asserts/string/minLength.js

@@ -1,12 +1,19 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk2AP4OQMTjs = require('../../chunk-2AP4OQMT.js');
+var _chunk5BVJ6YMHjs = require('../../chunk-5BVJ6YMH.js');
+
+
+var _chunkWK4O3HH4js = require('../../chunk-WK4O3HH4.js');
 
 // src/asserts/string/minLength.ts
-var minLength = (expected) => (received, pathToError) => {
-  if (received.length < expected)
-    _chunk2AP4OQMTjs.throwException.call(void 0, expected, received, pathToError, "The received value length is less than expected");
+var minLengthErrorMessage = "The received value length is less than expected";
+var minLengthErrorKey = "s:minLength";
+var minLength = (expected) => (received, ctx) => {
+  if (received.length < expected) _chunkWK4O3HH4js.guardException.call(void 0, expected, received, ctx, minLengthErrorMessage);
 };
+minLength.key = minLengthErrorKey;
+minLength.message = minLengthErrorMessage;
+_chunk5BVJ6YMHjs.setToDefaultLocale.call(void 0, minLength);
 
 
 exports.minLength = minLength;

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;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"]}
+{"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

@@ -1,12 +1,19 @@
 import {
-  throwException
-} from "../../chunk-QJOXKH7A.mjs";
+  setToDefaultLocale
+} from "../../chunk-3HTYHE2X.mjs";
+import {
+  guardException
+} from "../../chunk-7XFLH6R2.mjs";
 
 // src/asserts/string/minLength.ts
-var minLength = (expected) => (received, pathToError) => {
-  if (received.length < expected)
-    throwException(expected, received, pathToError, "The received value length is less than expected");
+var minLengthErrorMessage = "The received value length is less than expected";
+var minLengthErrorKey = "s:minLength";
+var minLength = (expected) => (received, ctx) => {
+  if (received.length < expected) guardException(expected, received, ctx, minLengthErrorMessage);
 };
+minLength.key = minLengthErrorKey;
+minLength.message = minLengthErrorMessage;
+setToDefaultLocale(minLength);
 export {
   minLength
 };

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

@@ -1 +1 @@
-{"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":[]}
+{"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

@@ -1,16 +1,21 @@
-import { R as RequiredValidation } from '../../CommonSchema-BIe85W_A.mjs';
+import { RequiredValidation } from '../../commonTypes.mjs';
 
 /**
- * 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. Throws an error if the received value does not match the expected pattern.
- *
+ * @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 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
- * parseSchema(schema, 'valid123'); // Valid
- * parseSchema(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'
+ * parseOrFail(schema, 'valid123');   // Valid
+ * parseOrFail(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'
+ *
+ * @translation Error Translation Key = 's:regExp'
  */
-declare const regExp: (expected: RegExp) => RequiredValidation;
+declare const regExp: {
+    (expected: RegExp): RequiredValidation;
+    key: string;
+    message: string;
+};
 
 export { regExp };

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

@@ -1,16 +1,21 @@
-import { R as RequiredValidation } from '../../CommonSchema-BIe85W_A.js';
+import { RequiredValidation } from '../../commonTypes.js';
 
 /**
- * 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. Throws an error if the received value does not match the expected pattern.
- *
+ * @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 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
- * parseSchema(schema, 'valid123'); // Valid
- * parseSchema(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'
+ * parseOrFail(schema, 'valid123');   // Valid
+ * parseOrFail(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'
+ *
+ * @translation Error Translation Key = 's:regExp'
  */
-declare const regExp: (expected: RegExp) => RequiredValidation;
+declare const regExp: {
+    (expected: RegExp): RequiredValidation;
+    key: string;
+    message: string;
+};
 
 export { regExp };

package/lib/asserts/string/regExp.js

@@ -1,12 +1,19 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk2AP4OQMTjs = require('../../chunk-2AP4OQMT.js');
+var _chunk5BVJ6YMHjs = require('../../chunk-5BVJ6YMH.js');
+
+
+var _chunkWK4O3HH4js = require('../../chunk-WK4O3HH4.js');
 
 // src/asserts/string/regExp.ts
-var regExp = (expected) => (received, pathToError) => {
-  if (!expected.test(received))
-    _chunk2AP4OQMTjs.throwException.call(void 0, expected, received, pathToError, "The received value does not match the required text pattern");
+var regExpErrorMessage = "The received value does not match the required text pattern";
+var regExpErrorKey = "s:regExp";
+var regExp = (expected) => (received, ctx) => {
+  if (!expected.test(received)) _chunkWK4O3HH4js.guardException.call(void 0, expected, received, ctx, regExpErrorMessage);
 };
+regExp.key = regExpErrorKey;
+regExp.message = regExpErrorMessage;
+_chunk5BVJ6YMHjs.setToDefaultLocale.call(void 0, regExp);
 
 
 exports.regExp = regExp;

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;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"]}
+{"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

@@ -1,12 +1,19 @@
 import {
-  throwException
-} from "../../chunk-QJOXKH7A.mjs";
+  setToDefaultLocale
+} from "../../chunk-3HTYHE2X.mjs";
+import {
+  guardException
+} from "../../chunk-7XFLH6R2.mjs";
 
 // 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");
+var regExpErrorMessage = "The received value does not match the required text pattern";
+var regExpErrorKey = "s:regExp";
+var regExp = (expected) => (received, ctx) => {
+  if (!expected.test(received)) guardException(expected, received, ctx, regExpErrorMessage);
 };
+regExp.key = regExpErrorKey;
+regExp.message = regExpErrorMessage;
+setToDefaultLocale(regExp);
 export {
   regExp
 };

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

@@ -1 +1 @@
-{"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":[]}
+{"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 };