bguard 0.5.0 → 0.6.0

package/lib/chunk-R25HSJPH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-R25HSJPH.js","../src/asserts/string/uuidV4.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,mBAAA,EAAqB,2CAAA;AAC3B,IAAM,eAAA,EAAiB,UAAA;AAEvB,IAAM,cAAA,EAAgB,wEAAA;AAgBf,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,GAAA,CAAI,QAAA,CAAS,SAAA,EAAW,QAAA,EAAU,cAAc,CAAA;AAAA,EAClD;AACF,CAAA;AAEA,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADdzB;AACA;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-R25HSJPH.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV4ErrorMessage = 'The received value is not a valid UUID v4';\nconst uuidV4ErrorKey = 's:uuidV4';\n\nconst uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[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 v4 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 v4.\n * @example\n * const schema = string().custom(uuidV4());\n * parseOrFail(schema, '123e4567-e89b-42d3-a456-426614174000'); // Valid\n * parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, '123e4567-e89b-a2d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, '123e4567-e89b-42d3-c456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v4'\n *\n * @translation Error Translation Key = 's:uuidV4'\n */\nexport const uuidV4 = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV4Pattern.test(received)) {\n    ctx.addIssue('uuid v4', received, uuidV4ErrorKey);\n  }\n};\n\nuuidV4.key = uuidV4ErrorKey;\nuuidV4.message = uuidV4ErrorMessage;\nsetToDefaultLocale(uuidV4);\n"]}

package/lib/chunk-S4FWDTEW.mjs

@@ -0,0 +1,20 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.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)) {
+    ctx.addIssue(`starts with '${substring}'`, received, startsWithErrorKey);
+  }
+};
+startsWith.key = startsWithErrorKey;
+startsWith.message = startsWithErrorMessage;
+setToDefaultLocale(startsWith);
+
+export {
+  startsWith
+};
+//# sourceMappingURL=chunk-S4FWDTEW.mjs.map

package/lib/chunk-S4FWDTEW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/startsWith.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\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      ctx.addIssue(`starts with '${substring}'`, received, startsWithErrorKey);\n    }\n  };\n\nstartsWith.key = startsWithErrorKey;\nstartsWith.message = startsWithErrorMessage;\nsetToDefaultLocale(startsWith);\n"],"mappings":";;;;;AAGA,IAAM,yBAAyB;AAC/B,IAAM,qBAAqB;AAcpB,IAAM,aACX,CAAC,cACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,WAAW,SAAS,GAAG;AACnC,QAAI,SAAS,gBAAgB,SAAS,KAAK,UAAU,kBAAkB;AAAA,EACzE;AACF;AAEF,WAAW,MAAM;AACjB,WAAW,UAAU;AACrB,mBAAmB,UAAU;","names":[]}

package/lib/chunk-S5D5AFDF.js

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+
+// src/asserts/string/regExp.ts
+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)) ctx.addIssue(expected, received, regExpErrorMessage);
+};
+regExp.key = regExpErrorKey;
+regExp.message = regExpErrorMessage;
+_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, regExp);
+
+
+
+exports.regExp = regExp;
+//# sourceMappingURL=chunk-S5D5AFDF.js.map

package/lib/chunk-S5D5AFDF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-S5D5AFDF.js","../src/asserts/string/regExp.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,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,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,kBAAkB,CAAA;AACnF,CAAA;AAEF,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADbzB;AACA;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-S5D5AFDF.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\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)) ctx.addIssue(expected, received, regExpErrorMessage);\n  };\n\nregExp.key = regExpErrorKey;\nregExp.message = regExpErrorMessage;\nsetToDefaultLocale(regExp);\n"]}

package/lib/chunk-SBO6OQIX.mjs

@@ -0,0 +1,23 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/string/isValidDate.ts
+var dateErrorMessage = "The received value is not a valid date";
+var dateErrorKey = "s:isValidDate";
+var dateRegexPattern = /^(19|20)\d\d-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+var isValidDate = () => {
+  return (received, ctx) => {
+    if (!dateRegexPattern.test(received)) {
+      ctx.addIssue(received, dateErrorMessage, dateErrorKey);
+    }
+  };
+};
+isValidDate.key = dateErrorKey;
+isValidDate.message = dateErrorMessage;
+setToDefaultLocale(isValidDate);
+
+export {
+  isValidDate
+};
+//# sourceMappingURL=chunk-SBO6OQIX.mjs.map

package/lib/chunk-SBO6OQIX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/isValidDate.ts"],"sourcesContent":["import { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst dateErrorMessage = 'The received value is not a valid date';\nconst dateErrorKey = 's:isValidDate';\n\n// Regex to match YYYY-MM-DD format\nconst dateRegexPattern = /^(19|20)\\d\\d-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$/;\n\n/**\n * @description Asserts that a string is a valid date in the format YYYY-MM-DD.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received string is not a valid date.\n * @example\n * const schema = string().custom(isValidDate());\n * parseOrFail(schema, \"2020-01-01\"); // Valid\n * parseOrFail(schema, \"2020-1-1\");   // Throws an error: 'The received value is not a valid date'\n * parseOrFail(schema, \"2020-01-32\"); // Throws an error: 'The received value is not a valid date'\n *\n * @translation Error Translation Key = 's:isValidDate'\n */\nexport const isValidDate = (): RequiredValidation => {\n  return (received: string, ctx: ExceptionContext) => {\n    if (!dateRegexPattern.test(received)) {\n      ctx.addIssue(received, dateErrorMessage, dateErrorKey);\n    }\n  };\n};\n\nisValidDate.key = dateErrorKey;\nisValidDate.message = dateErrorMessage;\nsetToDefaultLocale(isValidDate);\n"],"mappings":";;;;;AAGA,IAAM,mBAAmB;AACzB,IAAM,eAAe;AAGrB,IAAM,mBAAmB;AAclB,IAAM,cAAc,MAA0B;AACnD,SAAO,CAAC,UAAkB,QAA0B;AAClD,QAAI,CAAC,iBAAiB,KAAK,QAAQ,GAAG;AACpC,UAAI,SAAS,UAAU,kBAAkB,YAAY;AAAA,IACvD;AAAA,EACF;AACF;AAEA,YAAY,MAAM;AAClB,YAAY,UAAU;AACtB,mBAAmB,WAAW;","names":[]}

package/lib/chunk-SFIX77W5.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+
+// src/asserts/string/uuidV5.ts
+var uuidV5ErrorMessage = "The received value is not a valid UUID v5";
+var uuidV5ErrorKey = "s:uuidV5";
+var uuidV5Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var uuidV5 = () => (received, ctx) => {
+  if (!uuidV5Pattern.test(received)) {
+    ctx.addIssue("uuid v5", received, uuidV5ErrorKey);
+  }
+};
+uuidV5.key = uuidV5ErrorKey;
+uuidV5.message = uuidV5ErrorMessage;
+_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, uuidV5);
+
+
+
+exports.uuidV5 = uuidV5;
+//# sourceMappingURL=chunk-SFIX77W5.js.map

package/lib/chunk-SFIX77W5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-SFIX77W5.js","../src/asserts/string/uuidV5.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,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,GAAA,CAAI,QAAA,CAAS,SAAA,EAAW,QAAA,EAAU,cAAc,CAAA;AAAA,EAClD;AACF,CAAA;AAEA,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADZzB;AACA;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-SFIX77W5.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV5ErrorMessage = 'The received value is not a valid UUID v5';\nconst uuidV5ErrorKey = 's:uuidV5';\n\nconst uuidV5Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-5[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 v5 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 v5.\n * @example\n * const schema = string().custom(uuidV5());\n * parseOrFail(schema, '550e8400-e29b-51d4-a716-446655440000'); // Valid\n * parseOrFail(schema, '550e8400-e29b-41d4-a716-446655440000'); // Throws an error: 'The received value is not a valid UUID v5'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v5'\n *\n * @translation Error Translation Key = 's:uuidV5'\n */\nexport const uuidV5 = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV5Pattern.test(received)) {\n    ctx.addIssue('uuid v5', received, uuidV5ErrorKey);\n  }\n};\n\nuuidV5.key = uuidV5ErrorKey;\nuuidV5.message = uuidV5ErrorMessage;\nsetToDefaultLocale(uuidV5);\n"]}

package/lib/chunk-T2A3XXQZ.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/string/regExp.ts
+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)) ctx.addIssue(expected, received, regExpErrorMessage);
+};
+regExp.key = regExpErrorKey;
+regExp.message = regExpErrorMessage;
+setToDefaultLocale(regExp);
+
+export {
+  regExp
+};
+//# sourceMappingURL=chunk-T2A3XXQZ.mjs.map

package/lib/chunk-T2A3XXQZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/regExp.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\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)) ctx.addIssue(expected, received, regExpErrorMessage);\n  };\n\nregExp.key = regExpErrorKey;\nregExp.message = regExpErrorMessage;\nsetToDefaultLocale(regExp);\n"],"mappings":";;;;;AAGA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AAchB,IAAM,SACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,KAAK,QAAQ,EAAG,KAAI,SAAS,UAAU,UAAU,kBAAkB;AACnF;AAEF,OAAO,MAAM;AACb,OAAO,UAAU;AACjB,mBAAmB,MAAM;","names":[]}

package/lib/{chunk-P4Q22AZA.js → chunk-TCDQA2NU.js}

@@ -1,28 +1,31 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
 
-var _chunkMMWS3SXRjs = require('./chunk-MMWS3SXR.js');
+var _chunkVN4GLOENjs = require('./chunk-VN4GLOEN.js');
 
 
-var _chunkPE55R4KHjs = require('./chunk-PE55R4KH.js');
+var _chunkFIDPCCCWjs = require('./chunk-FIDPCCCW.js');
 
 
-var _chunkFIDPCCCWjs = require('./chunk-FIDPCCCW.js');
+var _chunkAXKX5BGHjs = require('./chunk-AXKX5BGH.js');
 
-// src/schemas/ArraySchema.ts
-var ArraySchema = (_class = class extends _chunkMMWS3SXRjs.CommonSchema {
+// src/asserts/array/index.ts
+function array(arraySchema) {
+  return new ArraySchema({ type: [], requiredValidations: [] }, arraySchema);
+}
+var ArraySchema = (_class = class extends _chunkVN4GLOENjs.CommonSchema {
   __init() {this._array = 1}
   constructor(ctx, arraySchema) {
     super(ctx);_class.prototype.__init.call(this);;
     this.validateArrayEntry(arraySchema);
-    this[_chunkPE55R4KHjs.ctxSymbol].array = arraySchema;
+    this[_chunkAXKX5BGHjs.ctxSymbol].array = arraySchema;
   }
   validateArrayEntry(arraySchema) {
     if (!arraySchema) throw new (0, _chunkFIDPCCCWjs.BuildSchemaError)("Missing schema in array method");
-    if (!(arraySchema instanceof _chunkMMWS3SXRjs.CommonSchema)) throw new (0, _chunkFIDPCCCWjs.BuildSchemaError)("Invalid schema in array method");
+    if (!(arraySchema instanceof _chunkVN4GLOENjs.CommonSchema)) throw new (0, _chunkFIDPCCCWjs.BuildSchemaError)("Invalid schema in array method");
   }
 }, _class);
 
 
 
-exports.ArraySchema = ArraySchema;
-//# sourceMappingURL=chunk-P4Q22AZA.js.map
+exports.array = array;
+//# sourceMappingURL=chunk-TCDQA2NU.js.map

package/lib/chunk-TCDQA2NU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-TCDQA2NU.js","../src/asserts/array/index.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACOO,SAAS,KAAA,CAA8B,WAAA,EAA2C;AACvF,EAAA,OAAO,IAAI,WAAA,CAAY,EAAE,IAAA,EAAM,CAAC,CAAA,EAAG,mBAAA,EAAqB,CAAC,EAAE,CAAA,EAAG,WAAW,CAAA;AAC3E;AAEA,IAAM,YAAA,YAAN,MAAA,QAA0B,8BAAa;AAAA,iBAC3B,OAAA,EAAS,EAAA;AAAA,EACnB,WAAA,CAAY,GAAA,EAAuB,WAAA,EAA2B;AAC5D,IAAA,KAAA,CAAM,GAAG,qCAAA;AACT,IAAA,IAAA,CAAK,kBAAA,CAAmB,WAAW,CAAA;AACnC,IAAA,IAAA,CAAK,0BAAS,CAAA,CAAE,MAAA,EAAQ,WAAA;AAAA,EAC1B;AAAA,EAEQ,kBAAA,CAAmB,WAAA,EAA2B;AACpD,IAAA,GAAA,CAAI,CAAC,WAAA,EAAa,MAAM,IAAI,sCAAA,CAAiB,gCAAgC,CAAA;AAC7E,IAAA,GAAA,CAAI,CAAA,CAAE,YAAA,WAAuB,6BAAA,CAAA,EAAe,MAAM,IAAI,sCAAA,CAAiB,gCAAgC,CAAA;AAAA,EACzG;AACF,UAAA;ADPA;AACA;AACE;AACF,sBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-TCDQA2NU.js","sourcesContent":[null,"import { type WithArray } from '../../commonTypes';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ctxSymbol } from '../../helpers/constants';\nimport { CommonSchema, type ValidatorContext } from '../../core';\n\n/**\n * @description Creates a new schema for validating arrays where each element must match the specified schema.\n * @template T\n * @param {T} arraySchema - The schema that each element of the array must match.\n * @returns {WithArray<ArraySchema, T>} A new instance of `ArraySchema` for validating arrays of elements that match the specified schema.\n * @example\n * const schema = array(string());\n * parseOrFail(schema, ['hello', 'world']); // Validates successfully\n * parseOrFail(schema, ['hello', 123]); // Throws a validation error\n *\n * @instance Of ArraySchema\n */\nexport function array<T extends CommonSchema>(arraySchema: T): WithArray<ArraySchema, T> {\n  return new ArraySchema({ type: [], requiredValidations: [] }, arraySchema) as WithArray<ArraySchema, T>;\n}\n\nclass ArraySchema extends CommonSchema {\n  protected _array = 1;\n  constructor(ctx: ValidatorContext, arraySchema: CommonSchema) {\n    super(ctx);\n    this.validateArrayEntry(arraySchema);\n    this[ctxSymbol].array = arraySchema;\n  }\n\n  private validateArrayEntry(arraySchema: CommonSchema) {\n    if (!arraySchema) throw new BuildSchemaError('Missing schema in array method');\n    if (!(arraySchema instanceof CommonSchema)) throw new BuildSchemaError('Invalid schema in array method');\n  }\n}\n"]}

package/lib/{chunk-YSCVE4PJ.mjs → chunk-THU5VBSO.mjs}

@@ -1,6 +1,6 @@
 import {
   ctxSymbol
-} from "./chunk-MQRXWXHP.mjs";
+} from "./chunk-2ANPCB4O.mjs";
 
 // src/helpers/setStrictType.ts
 function _setStrictType(that, val) {
@@ -11,4 +11,4 @@ function _setStrictType(that, val) {
 export {
   _setStrictType
 };
-//# sourceMappingURL=chunk-YSCVE4PJ.mjs.map
+//# sourceMappingURL=chunk-THU5VBSO.mjs.map

package/lib/chunk-THU5VBSO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/helpers/setStrictType.ts"],"sourcesContent":["import { ctxSymbol } from './constants';\nimport { type CommonSchema } from '../core';\n\nexport function _setStrictType(that: CommonSchema, val: unknown) {\n  that[ctxSymbol].strictType = true;\n  that[ctxSymbol].strictTypeValue = val;\n}\n"],"mappings":";;;;;AAGO,SAAS,eAAe,MAAoB,KAAc;AAC/D,OAAK,SAAS,EAAE,aAAa;AAC7B,OAAK,SAAS,EAAE,kBAAkB;AACpC;","names":[]}

package/lib/{chunk-EXVTHIT5.js → chunk-TJQ5NVL4.js}

@@ -30,7 +30,7 @@ function setToDefaultLocale({
 }
 function setLocale(lng, custom) {
   if (lng === "default") throw new (0, _chunkFIDPCCCWjs.BuildSchemaError)("Invalid language");
-  if (!data[lng]) data[lng] = { ...defaultErrorMap };
+  data[lng] ??= { ...defaultErrorMap };
   const locale = data[lng];
   Object.entries(custom).forEach(([messageKey, messageValue]) => {
     locale[messageKey] = messageValue;
@@ -52,4 +52,4 @@ function getTranslationByLocale(lng) {
 
 
 exports.setToDefaultLocale = setToDefaultLocale; exports.setLocale = setLocale; exports.clearLocales = clearLocales; exports.getTranslationByLocale = getTranslationByLocale;
-//# sourceMappingURL=chunk-EXVTHIT5.js.map
+//# sourceMappingURL=chunk-TJQ5NVL4.js.map

package/lib/chunk-TJQ5NVL4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-TJQ5NVL4.js","../src/translationMap.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACCA,IAAM,gBAAA,EAAuC;AAAA;AAAA,EAE3C,YAAA,EAAc,+BAAA;AAAA,EACd,YAAA,EAAc,0BAAA;AAAA,EACd,SAAA,EAAW,iDAAA;AAAA,EACX,cAAA,EAAgB,kDAAA;AAAA,EAChB,qBAAA,EAAuB,gEAAA;AAAA,EACvB,wBAAA,EAA0B,4CAAA;AAAA,EAC1B,oBAAA,EAAsB,yCAAA;AAAA,EACtB,eAAA,EAAiB,sBAAA;AAAA,EACjB,aAAA,EAAe,iCAAA;AAAA,EACf,QAAA,EAAU;AAAA;AAEZ,CAAA;AAEA,IAAI,KAAA,EAA+C;AAAA,EACjD,OAAA,EAAS,EAAE,GAAG,gBAAgB;AAChC,CAAA;AAEO,SAAS,kBAAA,CAAmB;AAAA,EACjC,GAAA;AAAA,EACA;AACF,CAAA,EAKG;AACD,EAAA,MAAM,cAAA,EAAgB,IAAA,CAAK,OAAA;AAC3B,EAAA,GAAA,CAAI,aAAA,CAAc,GAAG,CAAA,EAAG,MAAM,IAAI,sCAAA,CAAiB,+BAA+B,CAAA;AAClF,EAAA,aAAA,CAAc,GAAG,EAAA,EAAI,OAAA;AACvB;AAEO,SAAS,SAAA,CAAU,GAAA,EAAa,MAAA,EAAsC;AAC3E,EAAA,GAAA,CAAI,IAAA,IAAQ,SAAA,EAAW,MAAM,IAAI,sCAAA,CAAiB,kBAAkB,CAAA;AACpE,EAAA,IAAA,CAAK,GAAG,EAAA,IAAM,EAAE,GAAG,gBAAgB,CAAA;AACnC,EAAA,MAAM,OAAA,EAAS,IAAA,CAAK,GAAG,CAAA;AACvB,EAAA,MAAA,CAAO,OAAA,CAAQ,MAAM,CAAA,CAAE,OAAA,CAAQ,CAAC,CAAC,UAAA,EAAY,YAAY,CAAA,EAAA,GAAM;AAC7D,IAAA,MAAA,CAAO,UAAU,EAAA,EAAI,YAAA;AAAA,EACvB,CAAC,CAAA;AACH;AAEO,SAAS,YAAA,CAAA,EAAe;AAC7B,EAAA,KAAA,EAAO;AAAA,IACL,OAAA,EAAS,EAAE,GAAG,gBAAgB;AAAA,EAChC,CAAA;AACF;AAEO,SAAS,sBAAA,CAAuB,GAAA,EAAmC;AACxE,EAAA,GAAA,CAAI,CAAC,GAAA,EAAK,OAAO,IAAA,CAAK,SAAS,CAAA;AAC/B,EAAA,wBAAQ,IAAA,CAAK,GAAG,CAAA,UAAK,IAAA,CAAK,SAAS,GAAA;AACrC;ADTA;AACA;AACE;AACA;AACA;AACA;AACF,6KAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-TJQ5NVL4.js","sourcesContent":[null,"import { BuildSchemaError } from './exceptions';\nimport type { TranslationErrorMap } from './commonTypes';\nimport type { RequiredValidation } from './core';\n\n// c: stands for common\nconst defaultErrorMap: TranslationErrorMap = {\n  //@@start\n  'c:optional': 'The required value is missing',\n  'c:nullable': 'Value should not be null',\n  'c:array': 'Expected an array but received a different type',\n  'c:objectType': 'Expected an object but received a different type',\n  'c:objectTypeAsArray': 'Expected an object but received an array. Invalid type of data',\n  'c:unrecognizedProperty': 'This property is not allowed in the object',\n  'c:requiredProperty': 'Missing required property in the object',\n  'c:invalidType': 'Invalid type of data',\n  'c:isBoolean': 'The received value is not {{e}}',\n  'c:date': 'The received value is not a valid instance of Date',\n  //@@end\n};\n\nlet data: Record<string, Record<string, string>> = {\n  default: { ...defaultErrorMap },\n};\n\nexport function setToDefaultLocale({\n  key,\n  message,\n}: {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (expected: any): RequiredValidation;\n  key: string;\n  message: string;\n}) {\n  const defaultLocale = data.default!;\n  if (defaultLocale[key]) throw new BuildSchemaError('Duplicate default message key');\n  defaultLocale[key] = message;\n}\n\nexport function setLocale(lng: string, custom: Partial<TranslationErrorMap>) {\n  if (lng === 'default') throw new BuildSchemaError('Invalid language');\n  data[lng] ??= { ...defaultErrorMap };\n  const locale = data[lng];\n  Object.entries(custom).forEach(([messageKey, messageValue]) => {\n    locale[messageKey] = messageValue!;\n  });\n}\n\nexport function clearLocales() {\n  data = {\n    default: { ...defaultErrorMap },\n  };\n}\n\nexport function getTranslationByLocale(lng?: string): TranslationErrorMap {\n  if (!lng) return data['default'] as TranslationErrorMap;\n  return (data[lng] ?? data['default']) as TranslationErrorMap;\n}\n"]}

package/lib/{chunk-UTPG4GZB.js → chunk-TLPVFRWR.js}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkEXVTHIT5js = require('./chunk-EXVTHIT5.js');
+var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
 
 // src/asserts/mix/equalTo.ts
 var equalToErrorMessage = "The received value is not equal to expected";
@@ -10,9 +10,9 @@ var equalTo = (expected) => (received, ctx) => {
 };
 equalTo.key = equalToErrorKey;
 equalTo.message = equalToErrorMessage;
-_chunkEXVTHIT5js.setToDefaultLocale.call(void 0, equalTo);
+_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, equalTo);
 
 
 
 exports.equalTo = equalTo;
-//# sourceMappingURL=chunk-UTPG4GZB.js.map
+//# sourceMappingURL=chunk-TLPVFRWR.js.map

package/lib/chunk-TLPVFRWR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-TLPVFRWR.js","../src/asserts/mix/equalTo.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,oBAAA,EAAsB,6CAAA;AAC5B,IAAM,gBAAA,EAAkB,WAAA;AAejB,IAAM,QAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAmB,GAAA,EAAA,GAA0B;AAC5C,EAAA,GAAA,CAAI,SAAA,IAAa,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,eAAe,CAAA;AAC7E,CAAA;AAEF,OAAA,CAAQ,IAAA,EAAM,eAAA;AACd,OAAA,CAAQ,QAAA,EAAU,mBAAA;AAClB,iDAAA,OAA0B,CAAA;ADd1B;AACA;AACE;AACF,0BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-TLPVFRWR.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst equalToErrorMessage = 'The received value is not equal to expected';\nconst equalToErrorKey = 'm:equalTo';\n\n/**\n * @description Creates a custom assertion that checks if a value is equal to the expected value.\n * @notice It has already been implemented in the number, bigint and string schema. There is no need to use it as a custom assert.\n * @param {unknown} expected The value that the received value is expected to match.\n * @returns {RequiredValidation} A validation function that takes a received value and an exception context.\n * @throws {ValidationError} If the received value does not match the expected value.\n * @example\n * const schema = number().custom(equalTo(5)); // Define a schema with a custom assertion\n * parseOrFail(schema, 5); // Valid\n * parseOrFail(schema, 3); // Throws an error: 'The received value is not equal to expected'\n *\n * @translation Error Translation Key = 'm:equalTo'\n */\nexport const equalTo =\n  (expected: unknown): RequiredValidation =>\n  (received: unknown, ctx: ExceptionContext) => {\n    if (expected !== received) ctx.addIssue(expected, received, equalToErrorKey);\n  };\n\nequalTo.key = equalToErrorKey;\nequalTo.message = equalToErrorMessage;\nsetToDefaultLocale(equalTo);\n"]}

package/lib/chunk-TLRVQWCI.mjs

@@ -0,0 +1,30 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/string/isValidTime.ts
+var timeErrorMessage = "The received value is not a valid time";
+var timeErrorKey = "s:isValidTime";
+var isValidTime = (options = {}) => {
+  return (received, ctx) => {
+    const { precision } = options;
+    let timeRegex = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(\.\d+)?$/;
+    if (precision !== void 0) {
+      timeRegex = new RegExp(`^([01]\\d|2[0-3]):([0-5]\\d):([0-5]\\d)(\\.\\d{${precision}})?$`);
+    }
+    if (!timeRegex.test(received)) {
+      ctx.addIssue(received, timeErrorMessage, timeErrorKey);
+    }
+    if (precision !== void 0 && !received.includes(".")) {
+      ctx.addIssue(received, timeErrorMessage, timeErrorKey);
+    }
+  };
+};
+isValidTime.key = timeErrorKey;
+isValidTime.message = timeErrorMessage;
+setToDefaultLocale(isValidTime);
+
+export {
+  isValidTime
+};
+//# sourceMappingURL=chunk-TLRVQWCI.mjs.map

package/lib/chunk-TLRVQWCI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/isValidTime.ts"],"sourcesContent":["import { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst timeErrorMessage = 'The received value is not a valid time';\nconst timeErrorKey = 's:isValidTime';\n\ninterface IsValidTimeOptions {\n  precision?: number;\n}\n\n/**\n * @description Asserts that a string is a valid time in the format HH:mm:ss, with optional fractional seconds.\n * @param {IsValidTimeOptions} options Optional settings to configure the validation.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received string is not a valid time.\n * @example\n * const schema = string().custom(isValidTime());\n * parseOrFail(schema, \"00:00:00\"); // Valid\n * parseOrFail(schema, \"23:59:59.9999999\"); // Valid\n * parseOrFail(schema, \"00:00:00.256Z\");   // Throws an error: 'The received value is not a valid time'\n *\n * const schemaWithPrecision = string().custom(isValidTime({ precision: 3 }));\n * parseOrFail(schemaWithPrecision, \"00:00:00.256\"); // Valid\n * parseOrFail(schemaWithPrecision, \"00:00:00\");    // Throws an error: 'The received value is not a valid time'\n *\n * @translation Error Translation Key = 's:isValidTime'\n */\nexport const isValidTime = (options: IsValidTimeOptions = {}): RequiredValidation => {\n  return (received: string, ctx: ExceptionContext) => {\n    const { precision } = options;\n\n    // Base regex for HH:mm:ss format\n    let timeRegex = /^([01]\\d|2[0-3]):([0-5]\\d):([0-5]\\d)(\\.\\d+)?$/;\n\n    // If precision is specified, enforce exact number of digits in fractional seconds\n    if (precision !== undefined) {\n      timeRegex = new RegExp(`^([01]\\\\d|2[0-3]):([0-5]\\\\d):([0-5]\\\\d)(\\\\.\\\\d{${precision}})?$`);\n    }\n\n    // Check if the string is a valid time\n    if (!timeRegex.test(received)) {\n      ctx.addIssue(received, timeErrorMessage, timeErrorKey);\n    }\n\n    // Additional check for precision if it's specified and the time does not have fractional seconds\n    if (precision !== undefined && !received.includes('.')) {\n      ctx.addIssue(received, timeErrorMessage, timeErrorKey);\n    }\n  };\n};\n\nisValidTime.key = timeErrorKey;\nisValidTime.message = timeErrorMessage;\nsetToDefaultLocale(isValidTime);\n"],"mappings":";;;;;AAGA,IAAM,mBAAmB;AACzB,IAAM,eAAe;AAuBd,IAAM,cAAc,CAAC,UAA8B,CAAC,MAA0B;AACnF,SAAO,CAAC,UAAkB,QAA0B;AAClD,UAAM,EAAE,UAAU,IAAI;AAGtB,QAAI,YAAY;AAGhB,QAAI,cAAc,QAAW;AAC3B,kBAAY,IAAI,OAAO,kDAAkD,SAAS,MAAM;AAAA,IAC1F;AAGA,QAAI,CAAC,UAAU,KAAK,QAAQ,GAAG;AAC7B,UAAI,SAAS,UAAU,kBAAkB,YAAY;AAAA,IACvD;AAGA,QAAI,cAAc,UAAa,CAAC,SAAS,SAAS,GAAG,GAAG;AACtD,UAAI,SAAS,UAAU,kBAAkB,YAAY;AAAA,IACvD;AAAA,EACF;AACF;AAEA,YAAY,MAAM;AAClB,YAAY,UAAU;AACtB,mBAAmB,WAAW;","names":[]}

package/lib/chunk-TQDMUHTA.mjs

@@ -0,0 +1,20 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.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()) {
+    ctx.addIssue("upper case", received, upperCaseErrorKey);
+  }
+};
+upperCase.key = upperCaseErrorKey;
+upperCase.message = upperCaseErrorMessage;
+setToDefaultLocale(upperCase);
+
+export {
+  upperCase
+};
+//# sourceMappingURL=chunk-TQDMUHTA.mjs.map

package/lib/chunk-TQDMUHTA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/upperCase.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\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    ctx.addIssue('upper case', received, upperCaseErrorKey);\n  }\n};\n\nupperCase.key = upperCaseErrorKey;\nupperCase.message = upperCaseErrorMessage;\nsetToDefaultLocale(upperCase);\n"],"mappings":";;;;;AAGA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAcnB,IAAM,YAAY,MAA0B,CAAC,UAAkB,QAA0B;AAC9F,MAAI,aAAa,SAAS,YAAY,GAAG;AACvC,QAAI,SAAS,cAAc,UAAU,iBAAiB;AAAA,EACxD;AACF;AAEA,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}

package/lib/chunk-TZBAW5OO.mjs

@@ -0,0 +1,21 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/string/uuidV3.ts
+var uuidV3ErrorMessage = "The received value is not a valid UUID v3";
+var uuidV3ErrorKey = "s:uuidV3";
+var uuidV3Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var uuidV3 = () => (received, ctx) => {
+  if (!uuidV3Pattern.test(received)) {
+    ctx.addIssue("uuid v3", received, uuidV3ErrorKey);
+  }
+};
+uuidV3.key = uuidV3ErrorKey;
+uuidV3.message = uuidV3ErrorMessage;
+setToDefaultLocale(uuidV3);
+
+export {
+  uuidV3
+};
+//# sourceMappingURL=chunk-TZBAW5OO.mjs.map

package/lib/chunk-TZBAW5OO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/uuidV3.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV3ErrorMessage = 'The received value is not a valid UUID v3';\nconst uuidV3ErrorKey = 's:uuidV3';\n\nconst uuidV3Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-3[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 v3 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 v3.\n * @example\n * const schema = string().custom(uuidV3());\n * parseOrFail(schema, '550e8400-e29b-38d1-a456-426614174000'); // Valid\n * parseOrFail(schema, '550e8400-e29b-28d1-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v3'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v3'\n *\n * @translation Error Translation Key = 's:uuidV3'\n */\nexport const uuidV3 = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV3Pattern.test(received)) {\n    ctx.addIssue('uuid v3', received, uuidV3ErrorKey);\n  }\n};\n\nuuidV3.key = uuidV3ErrorKey;\nuuidV3.message = uuidV3ErrorMessage;\nsetToDefaultLocale(uuidV3);\n"],"mappings":";;;;;AAGA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AAEvB,IAAM,gBAAgB;AAcf,IAAM,SAAS,MAA0B,CAAC,UAAkB,QAA0B;AAC3F,MAAI,CAAC,cAAc,KAAK,QAAQ,GAAG;AACjC,QAAI,SAAS,WAAW,UAAU,cAAc;AAAA,EAClD;AACF;AAEA,OAAO,MAAM;AACb,OAAO,UAAU;AACjB,mBAAmB,MAAM;","names":[]}

package/lib/chunk-UHMICS34.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.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()) ctx.addIssue("lower case", received, lowerCaseErrorKey);
+};
+lowerCase.key = lowerCaseErrorKey;
+lowerCase.message = lowerCaseErrorMessage;
+setToDefaultLocale(lowerCase);
+
+export {
+  lowerCase
+};
+//# sourceMappingURL=chunk-UHMICS34.mjs.map

package/lib/chunk-UHMICS34.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/lowerCase.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\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()) ctx.addIssue('lower case', received, lowerCaseErrorKey);\n};\n\nlowerCase.key = lowerCaseErrorKey;\nlowerCase.message = lowerCaseErrorMessage;\nsetToDefaultLocale(lowerCase);\n"],"mappings":";;;;;AAGA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAanB,IAAM,YAAY,MAA0B,CAAC,UAAkB,QAA0B;AAC9F,MAAI,aAAa,SAAS,YAAY,EAAG,KAAI,SAAS,cAAc,UAAU,iBAAiB;AACjG;AAEA,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}

package/lib/chunk-UYQFYQQG.mjs

@@ -0,0 +1,69 @@
+import {
+  oneOfValues
+} from "./chunk-W3U7RYLP.mjs";
+import {
+  equalTo
+} from "./chunk-4ZKU4RJL.mjs";
+import {
+  _setStrictType
+} from "./chunk-THU5VBSO.mjs";
+import {
+  CommonSchema
+} from "./chunk-QIPGUTIG.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-ZTCXXAKD.mjs";
+import {
+  ONLY_ONCE
+} from "./chunk-2ANPCB4O.mjs";
+
+// src/asserts/string/index.ts
+function string() {
+  return new StringSchema({ type: ["string"], requiredValidations: [] });
+}
+var StringSchema = class extends CommonSchema {
+  _string = 1;
+  limit;
+  /**
+   * @method equalTo
+   * @description Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+   * @param expectedValue - The value that the schema must exactly match.
+   * @returns The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   * @example
+   * string().equalTo('hello'); // Infers the type 'hello'
+   *
+   * @public
+   */
+  equalTo(expectedValue) {
+    this.limitCheck();
+    _setStrictType(this, `'${expectedValue}'`);
+    return this.custom(equalTo(expectedValue));
+  }
+  /**
+   * @method oneOfValues
+   * @description Restricts the schema to match one of the specified values and infers the union of those values as the TypeScript type.
+   * @param expectedValues - An array of values that the schema can match.
+   * @returns The schema instance restricted to one of the specified values, with the union of those values inferred as the TypeScript type.
+   * @example
+   * string().oneOfValues(['foo', 'bar']); // Infers the type 'foo' | 'bar'
+   *
+   * @public
+   */
+  oneOfValues(expectedValue) {
+    this.limitCheck();
+    _setStrictType(
+      this,
+      expectedValue.map((el) => `'${el}'`)
+    );
+    return this.custom(oneOfValues(expectedValue));
+  }
+  limitCheck() {
+    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);
+    this.limit = true;
+  }
+};
+
+export {
+  string
+};
+//# sourceMappingURL=chunk-UYQFYQQG.mjs.map

package/lib/chunk-UYQFYQQG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/index.ts"],"sourcesContent":["import { WithBGuardType } from '../../commonTypes';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ONLY_ONCE } from '../../helpers/constants';\nimport { CommonSchema } from '../../core';\nimport { _setStrictType } from '../../helpers/setStrictType';\nimport { equalTo } from '../mix/equalTo';\nimport { oneOfValues } from '../mix/oneOfValues';\n\n/**\n * @description Creates a new schema for validating string values.\n * @returns {WithBGuardType<StringSchema, string>} A new instance of `StringSchema` for validating strings.\n * @example\n * const schema = string();\n * parseOrFail(schema, 'hello'); // Validates successfully\n * parseOrFail(schema, 123); // Throws a validation error\n *\n * @instance Of StringSchema\n */\nexport function string(): WithBGuardType<StringSchema, string> {\n  return new StringSchema({ type: ['string'], requiredValidations: [] }) as WithBGuardType<StringSchema, string>;\n}\n\nclass StringSchema extends CommonSchema {\n  protected _string = 1;\n  private limit: boolean | undefined;\n\n  /**\n   * @method equalTo\n   * @description Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.\n   * @param expectedValue - The value that the schema must exactly match.\n   * @returns The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type\n   * @example\n   * string().equalTo('hello'); // Infers the type 'hello'\n   *\n   * @public\n   */\n  public equalTo<Y extends string>(expectedValue: Y): WithBGuardType<this, Y> {\n    this.limitCheck();\n    _setStrictType(this, `'${expectedValue}'`);\n\n    return this.custom(equalTo(expectedValue)) as WithBGuardType<this, Y>;\n  }\n\n  /**\n   * @method oneOfValues\n   * @description Restricts the schema to match one of the specified values and infers the union of those values as the TypeScript type.\n   * @param expectedValues - An array of values that the schema can match.\n   * @returns The schema instance restricted to one of the specified values, with the union of those values inferred as the TypeScript type.\n   * @example\n   * string().oneOfValues(['foo', 'bar']); // Infers the type 'foo' | 'bar'\n   *\n   * @public\n   */\n  public oneOfValues<Y extends string>(expectedValue: Y[]): WithBGuardType<this, Y> {\n    this.limitCheck();\n    _setStrictType(\n      this,\n      expectedValue.map((el) => `'${el}'`),\n    );\n    return this.custom(oneOfValues(expectedValue)) as WithBGuardType<this, Y>;\n  }\n\n  private limitCheck() {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\n    this.limit = true;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAkBO,SAAS,SAA+C;AAC7D,SAAO,IAAI,aAAa,EAAE,MAAM,CAAC,QAAQ,GAAG,qBAAqB,CAAC,EAAE,CAAC;AACvE;AAEA,IAAM,eAAN,cAA2B,aAAa;AAAA,EAC5B,UAAU;AAAA,EACZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYD,QAA0B,eAA2C;AAC1E,SAAK,WAAW;AAChB,mBAAe,MAAM,IAAI,aAAa,GAAG;AAEzC,WAAO,KAAK,OAAO,QAAQ,aAAa,CAAC;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,YAA8B,eAA6C;AAChF,SAAK,WAAW;AAChB;AAAA,MACE;AAAA,MACA,cAAc,IAAI,CAAC,OAAO,IAAI,EAAE,GAAG;AAAA,IACrC;AACA,WAAO,KAAK,OAAO,YAAY,aAAa,CAAC;AAAA,EAC/C;AAAA,EAEQ,aAAa;AACnB,QAAI,KAAK,MAAO,OAAM,IAAI,iBAAiB,SAAS;AACpD,SAAK,QAAQ;AAAA,EACf;AACF;","names":[]}

package/lib/chunk-V2J4TQR5.mjs

@@ -0,0 +1,20 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/string/contains.ts
+var containsErrorMessage = "The received value does not contain the required substring";
+var containsErrorKey = "s:contains";
+var contains = (substring) => (received, ctx) => {
+  if (!received.includes(substring)) {
+    ctx.addIssue(`contains '${substring}'`, received, containsErrorKey);
+  }
+};
+contains.key = containsErrorKey;
+contains.message = containsErrorMessage;
+setToDefaultLocale(contains);
+
+export {
+  contains
+};
+//# sourceMappingURL=chunk-V2J4TQR5.mjs.map

package/lib/chunk-V2J4TQR5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/contains.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst containsErrorMessage = 'The received value does not contain the required substring';\nconst containsErrorKey = 's:contains';\n\n/**\n * @description Asserts that a string value contains a specified substring.\n * @param {string} substring The substring that must be present in the string value.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not contain the required substring.\n * @example\n * const schema = string().custom(contains('foo'));\n * parseOrFail(schema, 'foobar'); // Valid\n * parseOrFail(schema, 'bar'); // Throws an error: 'The received value does not contain the required substring'\n *\n * @translation Error Translation Key = 's:contains'\n */\nexport const contains =\n  (substring: string): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!received.includes(substring)) {\n      ctx.addIssue(`contains '${substring}'`, received, containsErrorKey);\n    }\n  };\n\ncontains.key = containsErrorKey;\ncontains.message = containsErrorMessage;\nsetToDefaultLocale(contains);\n"],"mappings":";;;;;AAGA,IAAM,uBAAuB;AAC7B,IAAM,mBAAmB;AAclB,IAAM,WACX,CAAC,cACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,SAAS,SAAS,GAAG;AACjC,QAAI,SAAS,aAAa,SAAS,KAAK,UAAU,gBAAgB;AAAA,EACpE;AACF;AAEF,SAAS,MAAM;AACf,SAAS,UAAU;AACnB,mBAAmB,QAAQ;","names":[]}

package/lib/chunk-V7C77FML.mjs

@@ -0,0 +1,18 @@
+import {
+  setToDefaultLocale
+} from "./chunk-OE3L7EKN.mjs";
+
+// src/asserts/number/minExcluded.ts
+var minExcludedErrorMessage = "The received value is less than or equal to expected";
+var minExcludedErrorKey = "n:minExcluded";
+var minExcluded = (expected) => (received, ctx) => {
+  if (expected >= received) ctx.addIssue(expected, received, minExcludedErrorKey);
+};
+minExcluded.key = minExcludedErrorKey;
+minExcluded.message = minExcludedErrorMessage;
+setToDefaultLocale(minExcluded);
+
+export {
+  minExcluded
+};
+//# sourceMappingURL=chunk-V7C77FML.mjs.map

package/lib/chunk-V7C77FML.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/number/minExcluded.ts"],"sourcesContent":["import { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst minExcludedErrorMessage = 'The received value is less than or equal to expected';\nconst minExcludedErrorKey = 'n:minExcluded';\n\n/**\n * @description Asserts that a number value is strictly greater than a specified minimum value (i.e., the minimum value is excluded).\n * @param {number} expected The minimum allowable value, which is excluded.\n * @returns {RequiredValidation} A validation function that takes a received number and an exception context.\n * @throws {ValidationError} if the received value is less than or equal to the expected minimum value.\n * @example\n * const schema = number().custom(minExcluded(10));\n * parseOrFail(schema, 11);  // Valid\n * parseOrFail(schema, 10); // Throws an error: 'The received value is less than or equal to expected'\n * parseOrFail(schema, 9);  // Throws an error: 'The received value is less than or equal to expected'\n *\n * @translation Error Translation Key = 'n:minExcluded'\n */\nexport const minExcluded =\n  (expected: number): RequiredValidation =>\n  (received: number, ctx: ExceptionContext) => {\n    if (expected >= received) ctx.addIssue(expected, received, minExcludedErrorKey);\n  };\n\nminExcluded.key = minExcludedErrorKey;\nminExcluded.message = minExcludedErrorMessage;\nsetToDefaultLocale(minExcluded);\n"],"mappings":";;;;;AAGA,IAAM,0BAA0B;AAChC,IAAM,sBAAsB;AAerB,IAAM,cACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,YAAY,SAAU,KAAI,SAAS,UAAU,UAAU,mBAAmB;AAChF;AAEF,YAAY,MAAM;AAClB,YAAY,UAAU;AACtB,mBAAmB,WAAW;","names":[]}