typia 15.0.0 → 15.1.0

package/lib/module.js

@@ -37,27 +37,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reflect = exports.protobuf = exports.notations = exports.plain = exports.json = exports.llm = exports.http = exports.functional = exports.compare = void 0;
-exports.assert = assert;
-exports.assertGuard = assertGuard;
-exports.is = is;
-exports.shallow = shallow;
-exports.validate = validate;
-exports.assertEquals = assertEquals;
-exports.assertGuardEquals = assertGuardEquals;
-exports.equals = equals;
-exports.validateEquals = validateEquals;
-exports.random = random;
-exports.createAssert = createAssert;
-exports.createAssertGuard = createAssertGuard;
-exports.createIs = createIs;
-exports.createShallow = createShallow;
-exports.createValidate = createValidate;
-exports.createAssertEquals = createAssertEquals;
-exports.createAssertGuardEquals = createAssertGuardEquals;
-exports.createEquals = createEquals;
-exports.createValidateEquals = createValidateEquals;
-exports.createRandom = createRandom;
-const NoTransformConfigurationError_1 = require("./transformers/NoTransformConfigurationError");
 exports.compare = __importStar(require("./compare"));
 exports.functional = __importStar(require("./functional"));
 exports.http = __importStar(require("./http"));
@@ -69,84 +48,5 @@ exports.protobuf = __importStar(require("./protobuf"));
 exports.reflect = __importStar(require("./reflect"));
 __exportStar(require("./TypeGuardError"), exports);
 __exportStar(require("./re-exports"), exports);
-/** @internal */
-function assert() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("assert");
-}
-/** @internal */
-function assertGuard() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("assertGuard");
-}
-/** @internal */
-function is() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("is");
-}
-/** @internal */
-function shallow() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("shallow");
-}
-/** @internal */
-function validate() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("validate");
-}
-/** @internal */
-function assertEquals() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("assertEquals");
-}
-/** @internal */
-function assertGuardEquals() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("assertGuardEquals");
-}
-/** @internal */
-function equals() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("equals");
-}
-/** @internal */
-function validateEquals() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("validateEquals");
-}
-/** @internal */
-function random() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("random");
-}
-/** @internal */
-function createAssert() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createAssert");
-}
-/** @internal */
-function createAssertGuard() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createAssertGuard");
-}
-/** @internal */
-function createIs() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createIs");
-}
-/** @internal */
-function createShallow() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createShallow");
-}
-/** @internal */
-function createValidate() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createValidate");
-}
-/** @internal */
-function createAssertEquals() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createAssertEquals");
-}
-/** @internal */
-function createAssertGuardEquals() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createAssertGuardEquals");
-}
-/** @internal */
-function createEquals() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createEquals");
-}
-/** @internal */
-function createValidateEquals() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createValidateEquals");
-}
-/** @internal */
-function createRandom() {
-    (0, NoTransformConfigurationError_1.NoTransformConfigurationError)("createRandom");
-}
+__exportStar(require("./basic"), exports);
 //# sourceMappingURL=module.js.map

package/lib/module.js.map

@@ -1 +1 @@
-{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,gGAA6F;AAE7F,QAAY,OAAO,sCAAkB;AACrC,QAAY,UAAU,yCAAqB;AAC3C,QAAY,IAAI,mCAAe;AAC/B,QAAY,GAAG,kCAAc;AAC7B,QAAY,IAAI,mCAAe;AAC/B,QAAY,KAAK,oCAAgB;AACjC,QAAY,SAAS,wCAAoB;AACzC,QAAY,QAAQ,uCAAmB;AACvC,QAAY,OAAO,sCAAkB;AAErC,mDAAiC;AAEjC,+CAA6B;AA+D7B,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,QAAQ,CAAC,CAAC;AAC1C,CAAC;AA4DD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,aAAa,CAAC,CAAC;AAC/C,CAAC;AA0CD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,IAAI,CAAC,CAAC;AACtC,CAAC;AAgED,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,SAAS,CAAC,CAAC;AAC3C,CAAC;AAoDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,UAAU,CAAC,CAAC;AAC5C,CAAC;AAyDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAoDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AACrD,CAAC;AAwCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,QAAQ,CAAC,CAAC;AAC1C,CAAC;AAkDD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAgCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,QAAQ,CAAC,CAAC;AAC1C,CAAC;AAwCD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AA+CD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AACrD,CAAC;AAyBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,UAAU,CAAC,CAAC;AAC5C,CAAC;AA+BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,eAAe,CAAC,CAAC;AACjD,CAAC;AA4BD,gBAAgB;AAChB;IAEE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAsCD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,oBAAoB,CAAC,CAAC;AACtD,CAAC;AA+CD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAyBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AA8BD,gBAAgB;AAChB;IAEE,IAAA,6DAA6B,EAAC,sBAAsB,CAAC,CAAC;AACxD,CAAC;AA6BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC"}
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,QAAY,OAAO,sCAAkB;AACrC,QAAY,UAAU,yCAAqB;AAC3C,QAAY,IAAI,mCAAe;AAC/B,QAAY,GAAG,kCAAc;AAC7B,QAAY,IAAI,mCAAe;AAC/B,QAAY,KAAK,oCAAgB;AACjC,QAAY,SAAS,wCAAoB;AACzC,QAAY,QAAQ,uCAAmB;AACvC,QAAY,OAAO,sCAAkB;AAErC,mDAAiC;AAEjC,+CAA6B;AAE7B,0CAAwB"}

package/lib/module.mjs

@@ -1,6 +1,6 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { TypeGuardError } from "./TypeGuardError.mjs";
-import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+import { assert, assertEquals, assertGuard, assertGuardEquals, createAssert, createAssertEquals, createAssertGuard, createAssertGuardEquals, createEquals, createIs, createRandom, createShallow, createValidate, createValidateEquals, equals, is, random, shallow, validate, validateEquals } from "./basic.mjs";
 import { compare_exports } from "./compare.mjs";
 import { functional_exports } from "./functional.mjs";
 import { http_exports } from "./http.mjs";
@@ -45,86 +45,6 @@ var module_exports = /* @__PURE__ */ __exportAll({
 	validate: () => validate,
 	validateEquals: () => validateEquals
 });
-/** @internal */
-function assert() {
-	NoTransformConfigurationError("assert");
-}
-/** @internal */
-function assertGuard() {
-	NoTransformConfigurationError("assertGuard");
-}
-/** @internal */
-function is() {
-	NoTransformConfigurationError("is");
-}
-/** @internal */
-function shallow() {
-	NoTransformConfigurationError("shallow");
-}
-/** @internal */
-function validate() {
-	NoTransformConfigurationError("validate");
-}
-/** @internal */
-function assertEquals() {
-	NoTransformConfigurationError("assertEquals");
-}
-/** @internal */
-function assertGuardEquals() {
-	NoTransformConfigurationError("assertGuardEquals");
-}
-/** @internal */
-function equals() {
-	NoTransformConfigurationError("equals");
-}
-/** @internal */
-function validateEquals() {
-	NoTransformConfigurationError("validateEquals");
-}
-/** @internal */
-function random() {
-	NoTransformConfigurationError("random");
-}
-/** @internal */
-function createAssert() {
-	NoTransformConfigurationError("createAssert");
-}
-/** @internal */
-function createAssertGuard() {
-	NoTransformConfigurationError("createAssertGuard");
-}
-/** @internal */
-function createIs() {
-	NoTransformConfigurationError("createIs");
-}
-/** @internal */
-function createShallow() {
-	NoTransformConfigurationError("createShallow");
-}
-/** @internal */
-function createValidate() {
-	NoTransformConfigurationError("createValidate");
-}
-/** @internal */
-function createAssertEquals() {
-	NoTransformConfigurationError("createAssertEquals");
-}
-/** @internal */
-function createAssertGuardEquals() {
-	NoTransformConfigurationError("createAssertGuardEquals");
-}
-/** @internal */
-function createEquals() {
-	NoTransformConfigurationError("createEquals");
-}
-/** @internal */
-function createValidateEquals() {
-	NoTransformConfigurationError("createValidateEquals");
-}
-/** @internal */
-function createRandom() {
-	NoTransformConfigurationError("createRandom");
-}
 //#endregion
 export { TypeGuardError, assert, assertEquals, assertGuard, assertGuardEquals, compare_exports as compare, createAssert, createAssertEquals, createAssertGuard, createAssertGuardEquals, createEquals, createIs, createRandom, createShallow, createValidate, createValidateEquals, equals, functional_exports as functional, http_exports as http, is, json_exports as json, llm_exports as llm, module_exports, notations_exports as notations, plain_exports as plain, protobuf_exports as protobuf, random, reflect_exports as reflect, shallow, tags, validate, validateEquals };
 

package/lib/module.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"module.mjs","names":[],"sources":["../src/module.ts"],"sourcesContent":["import {\n  IRandomGenerator,\n  IValidation,\n  Resolved,\n  StandardSchemaV1,\n} from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\nexport * as compare from \"./compare\";\nexport * as functional from \"./functional\";\nexport * as http from \"./http\";\nexport * as llm from \"./llm\";\nexport * as json from \"./json\";\nexport * as plain from \"./plain\";\nexport * as notations from \"./notations\";\nexport * as protobuf from \"./protobuf\";\nexport * as reflect from \"./reflect\";\n\nexport * from \"./TypeGuardError\";\n\nexport * from \"./re-exports\";\n\n/* -----------------------------------------------------------\n    BASIC VALIDATORS\n----------------------------------------------------------- */\n/**\n * Asserts type `T`.\n *\n * Performs runtime type checking against compile-time type `T`. Stops at first\n * mismatch and throws {@link TypeGuardError} containing:\n *\n * - `path`: Property path where error occurred (e.g., `\"input.user.age\"`)\n * - `expected`: Expected type string (e.g., `\"number & ExclusiveMinimum<19>\"`)\n * - `value`: Actual value that failed validation\n *\n * Related functions:\n *\n * - {@link is} — Returns `boolean` instead of throwing\n * - {@link validate} — Collects all errors instead of stopping at first\n * - {@link assertGuard} — Type guard with no return value (narrows type only)\n * - {@link assertEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n * @param input Value to assert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns The input value typed as `T`\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assert<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/**\n * Asserts type `T`.\n *\n * Performs runtime type checking against compile-time type `T`. Stops at first\n * mismatch and throws {@link TypeGuardError} containing:\n *\n * - `path`: Property path where error occurred (e.g., `\"input.user.age\"`)\n * - `expected`: Expected type string (e.g., `\"number & ExclusiveMinimum<19>\"`)\n * - `value`: Actual value that failed validation\n *\n * Related functions:\n *\n * - {@link is} — Returns `boolean` instead of throwing\n * - {@link validate} — Collects all errors instead of stopping at first\n * - {@link assertGuard} — Type guard with no return value (narrows type only)\n * - {@link assertEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n * @param input Value to assert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns The input value typed as `T`\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assert<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assert(): never {\n  NoTransformConfigurationError(\"assert\");\n}\n\n/**\n * Asserts type `T` as assertion guard.\n *\n * Unlike {@link assert}, returns nothing (`asserts input is T`). After this\n * call, TypeScript narrows `input` to type `T` in subsequent code. Useful when\n * you need type narrowing with runtime validation but don't need the return\n * value.\n *\n * Throws {@link TypeGuardError} on first mismatch with `path`, `expected`, and\n * `value`.\n *\n * Related functions:\n *\n * - {@link assert} — Same validation but returns the input value\n * - {@link is} — Returns `boolean` instead of throwing\n * - {@link validate} — Collects all errors instead of throwing\n * - {@link assertGuardEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n * @param input Value to assert (narrowed to `T` after call)\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertGuard<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): asserts input is T;\n\n/**\n * Asserts type `T` as assertion guard.\n *\n * Unlike {@link assert}, returns nothing (`asserts input is T`). After this\n * call, TypeScript narrows `input` to type `T` in subsequent code. Useful when\n * you need type narrowing with runtime validation but don't need the return\n * value.\n *\n * Throws {@link TypeGuardError} on first mismatch with `path`, `expected`, and\n * `value`.\n *\n * Related functions:\n *\n * - {@link assert} — Same validation but returns the input value\n * - {@link is} — Returns `boolean` instead of throwing\n * - {@link validate} — Collects all errors instead of throwing\n * - {@link assertGuardEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n * @param input Value to assert (narrowed to `T` after call)\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertGuard<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): asserts input is T;\n\n/** @internal */\nexport function assertGuard(): never {\n  NoTransformConfigurationError(\"assertGuard\");\n}\n\n/**\n * Tests type `T`.\n *\n * Performs runtime type checking without throwing exceptions. Acts as\n * TypeScript type guard, narrowing the input type in conditional branches when\n * result is `true`.\n *\n * Related functions:\n *\n * - {@link assert} — Throws {@link TypeGuardError} with detailed error info on\n *   mismatch\n * - {@link validate} — Returns all errors without throwing\n * - {@link equals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to check\n * @param input Value to test\n * @returns `true` if valid, `false` otherwise (type predicate `input is T`)\n */\nexport function is<T>(input: T): input is T;\n\n/**\n * Tests type `T`.\n *\n * Performs runtime type checking without throwing exceptions. Acts as\n * TypeScript type guard, narrowing the input type in conditional branches when\n * result is `true`.\n *\n * Related functions:\n *\n * - {@link assert} — Throws {@link TypeGuardError} with detailed error info on\n *   mismatch\n * - {@link validate} — Returns all errors without throwing\n * - {@link equals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to check\n * @param input Value to test\n * @returns `true` if valid, `false` otherwise (type predicate `input is T`)\n */\nexport function is<T>(input: unknown): input is T;\n\n/** @internal */\nexport function is(): never {\n  NoTransformConfigurationError(\"is\");\n}\n\n/**\n * Tests type `T` up to a limited depth.\n *\n * Like {@link is}, but only descends into nested objects, arrays, and tuples\n * until the depth budget `N` is exhausted; beyond that point a value is\n * accepted as long as it is an `object` (or `null` where the type permits).\n * Useful for **discrimination** rather than full validation — when you only\n * need to know which branch of a union an input belongs to, paying for a deep\n * structural check of every leaf is wasteful.\n *\n * Because the check is shallow past depth `N`, a `true` result is **not** a\n * guarantee that the whole value conforms to `T`. The name `shallow` reflects\n * this: only the discriminating, near-surface part of the type is verified. For\n * a full guarantee, use {@link is}.\n *\n * Related functions:\n *\n * - {@link is} — Full-depth check, returns a sound type guard\n * - {@link assert} — Throws {@link TypeGuardError} with detailed error info on\n *   mismatch\n * - {@link validate} — Returns all errors without throwing\n *\n * @template T Target type to check\n * @template N Maximum depth to descend before accepting a value structurally.\n *   Must be a non-negative integer literal. Defaults to `2`.\n * @param input Value to test\n * @returns `true` if valid up to depth `N`, `false` otherwise (type predicate\n *   `input is T`)\n */\nexport function shallow<T, N extends number = 2>(input: T): input is T;\n\n/**\n * Tests type `T` up to a limited depth.\n *\n * Like {@link is}, but only descends into nested objects, arrays, and tuples\n * until the depth budget `N` is exhausted; beyond that point a value is\n * accepted as long as it is an `object` (or `null` where the type permits).\n * Useful for **discrimination** rather than full validation — when you only\n * need to know which branch of a union an input belongs to, paying for a deep\n * structural check of every leaf is wasteful.\n *\n * Because the check is shallow past depth `N`, a `true` result is **not** a\n * guarantee that the whole value conforms to `T`. The name `shallow` reflects\n * this: only the discriminating, near-surface part of the type is verified. For\n * a full guarantee, use {@link is}.\n *\n * Related functions:\n *\n * - {@link is} — Full-depth check, returns a sound type guard\n * - {@link assert} — Throws {@link TypeGuardError} with detailed error info on\n *   mismatch\n * - {@link validate} — Returns all errors without throwing\n *\n * @template T Target type to check\n * @template N Maximum depth to descend before accepting a value structurally.\n *   Must be a non-negative integer literal. Defaults to `2`.\n * @param input Value to test\n * @returns `true` if valid up to depth `N`, `false` otherwise (type predicate\n *   `input is T`)\n */\nexport function shallow<T, N extends number = 2>(input: unknown): input is T;\n\n/** @internal */\nexport function shallow(): never {\n  NoTransformConfigurationError(\"shallow\");\n}\n\n/**\n * Validates type `T`.\n *\n * Unlike {@link assert} which throws on first error, this function continues\n * checking and collects all type mismatches into {@link IValidation.errors}\n * array. Never throws.\n *\n * Return structure:\n *\n * - `success: true` → `data` contains validated input as `T`\n * - `success: false` → `errors` array of {@link IValidation.IError} with `path`,\n *   `expected`, `value`\n *\n * Related functions:\n *\n * - {@link assert} — Throws on first error instead of collecting all\n * - {@link is} — Simple boolean check\n * - {@link validateEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n * @param input Value to validate\n * @returns {@link IValidation} <T> containing either `data` or `errors`\n */\nexport function validate<T>(input: T): IValidation<T>;\n\n/**\n * Validates type `T`.\n *\n * Unlike {@link assert} which throws on first error, this function continues\n * checking and collects all type mismatches into {@link IValidation.errors}\n * array. Never throws.\n *\n * Return structure:\n *\n * - `success: true` → `data` contains validated input as `T`\n * - `success: false` → `errors` array of {@link IValidation.IError} with `path`,\n *   `expected`, `value`\n *\n * Related functions:\n *\n * - {@link assert} — Throws on first error instead of collecting all\n * - {@link is} — Simple boolean check\n * - {@link validateEquals} — Also rejects properties not defined in `T`\n *\n * @template T Target type to validate against\n * @param input Value to validate\n * @returns {@link IValidation} <T> containing either `data` or `errors`\n */\nexport function validate<T>(input: unknown): IValidation<T>;\n\n/** @internal */\nexport function validate(): never {\n  NoTransformConfigurationError(\"validate\");\n}\n\n/* -----------------------------------------------------------\n    STRICT VALIDATORS\n----------------------------------------------------------- */\n/**\n * Asserts type `T` with strict equality.\n *\n * Stricter than {@link assert}: also fails when input contains any property not\n * defined in type `T`. For extra property errors, `expected` will be\n * `\"undefined\"`.\n *\n * Related functions:\n *\n * - {@link assert} — Allows extra properties\n * - {@link equals} — Boolean result without throwing\n * - {@link validateEquals} — Collects all errors without throwing\n * - {@link assertGuardEquals} — Type guard version with no return value\n *\n * @template T Target type for exact match\n * @param input Value to validate\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns The input value typed as `T`\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertEquals<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/**\n * Asserts type `T` with strict equality.\n *\n * Stricter than {@link assert}: also fails when input contains any property not\n * defined in type `T`. For extra property errors, `expected` will be\n * `\"undefined\"`.\n *\n * Related functions:\n *\n * - {@link assert} — Allows extra properties\n * - {@link equals} — Boolean result without throwing\n * - {@link validateEquals} — Collects all errors without throwing\n * - {@link assertGuardEquals} — Type guard version with no return value\n *\n * @template T Target type for exact match\n * @param input Value to validate\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns The input value typed as `T`\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertEquals<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertEquals(): never {\n  NoTransformConfigurationError(\"assertEquals\");\n}\n\n/**\n * Asserts type `T` with strict equality as assertion guard.\n *\n * Combines {@link assertGuard} with strict equality checking. Returns nothing\n * but narrows input to type `T`. Also fails when input contains properties not\n * in `T`.\n *\n * Related functions:\n *\n * - {@link assertGuard} — Allows extra properties\n * - {@link assertEquals} — Returns value instead of type guard\n * - {@link equals} — Boolean result without throwing\n * - {@link validateEquals} — Collects all errors without throwing\n *\n * @template T Target type for exact match\n * @param input Value to assert (narrowed to `T` after call)\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertGuardEquals<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): asserts input is T;\n\n/**\n * Asserts type `T` with strict equality as assertion guard.\n *\n * Combines {@link assertGuard} with strict equality checking. Returns nothing\n * but narrows input to type `T`. Also fails when input contains properties not\n * in `T`.\n *\n * Related functions:\n *\n * - {@link assertGuard} — Allows extra properties\n * - {@link assertEquals} — Returns value instead of type guard\n * - {@link equals} — Boolean result without throwing\n * - {@link validateEquals} — Collects all errors without throwing\n *\n * @template T Target type for exact match\n * @param input Value to assert (narrowed to `T` after call)\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertGuardEquals<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): asserts input is T;\n\n/** @internal */\nexport function assertGuardEquals(): never {\n  NoTransformConfigurationError(\"assertGuardEquals\");\n}\n\n/**\n * Tests type `T` with strict equality.\n *\n * Stricter than {@link is}: also returns `false` when input contains any\n * property not defined in type `T`. Useful for detecting unexpected data or\n * typos.\n *\n * Related functions:\n *\n * - {@link is} — Allows extra properties\n * - {@link assertEquals} — Throws with detailed error info on mismatch\n * - {@link validateEquals} — Returns all errors without throwing\n *\n * @template T Target type for exact match\n * @param input Value to test\n * @returns `true` if valid, `false` otherwise (type predicate `input is T`)\n */\nexport function equals<T>(input: T): input is T;\n\n/**\n * Tests type `T` with strict equality.\n *\n * Stricter than {@link is}: also returns `false` when input contains any\n * property not defined in type `T`. Useful for detecting unexpected data or\n * typos.\n *\n * Related functions:\n *\n * - {@link is} — Allows extra properties\n * - {@link assertEquals} — Throws with detailed error info on mismatch\n * - {@link validateEquals} — Returns all errors without throwing\n *\n * @template T Target type for exact match\n * @param input Value to test\n * @returns `true` if valid, `false` otherwise (type predicate `input is T`)\n */\nexport function equals<T>(input: unknown): input is T;\n\n/** @internal */\nexport function equals(): never {\n  NoTransformConfigurationError(\"equals\");\n}\n\n/**\n * Validates type `T` with strict equality.\n *\n * Combines {@link validate} with strict equality checking. Collects all errors\n * including extra property violations into {@link IValidation.errors} array.\n *\n * Return structure:\n *\n * - `success: true` → `data` contains validated input as `T`\n * - `success: false` → `errors` array with `path`, `expected`, `value` for each\n *   mismatch\n *\n * Related functions:\n *\n * - {@link validate} — Allows extra properties\n * - {@link assertEquals} — Throws on first error\n * - {@link equals} — Simple boolean check\n *\n * @template T Target type for exact match\n * @param input Value to validate\n * @returns {@link IValidation} <T> containing either `data` or `errors`\n */\nexport function validateEquals<T>(input: T): IValidation<T>;\n\n/**\n * Validates type `T` with strict equality.\n *\n * Combines {@link validate} with strict equality checking. Collects all errors\n * including extra property violations into {@link IValidation.errors} array.\n *\n * Return structure:\n *\n * - `success: true` → `data` contains validated input as `T`\n * - `success: false` → `errors` array with `path`, `expected`, `value` for each\n *   mismatch\n *\n * Related functions:\n *\n * - {@link validate} — Allows extra properties\n * - {@link assertEquals} — Throws on first error\n * - {@link equals} — Simple boolean check\n *\n * @template T Target type for exact match\n * @param input Value to validate\n * @returns {@link IValidation} <T> containing either `data` or `errors`\n */\nexport function validateEquals<T>(input: unknown): IValidation<T>;\n\n/** @internal */\nexport function validateEquals(): never {\n  NoTransformConfigurationError(\"validateEquals\");\n}\n\n/* -----------------------------------------------------------\n    RANDOM\n----------------------------------------------------------- */\n/**\n * Generates random data of type `T`.\n *\n * Creates random instance conforming to compile-time type `T`. Generates only\n * primitive data; methods in `T` are ignored. If `T` has `toJSON()` method,\n * generates its return type instead.\n *\n * @template T Type of data to generate\n * @param generator Custom random generator implementing {@link IRandomGenerator}\n * @returns Randomly generated data as `Resolved<T>`\n * @danger You must configure the generic argument `T`\n */\nexport function random(generator?: Partial<IRandomGenerator>): never;\n\n/**\n * Generates random data of type `T`.\n *\n * Creates random instance conforming to compile-time type `T`. Generates only\n * primitive data; methods in `T` are ignored. If `T` has `toJSON()` method,\n * generates its return type instead.\n *\n * @template T Type of data to generate\n * @param generator Custom random generator implementing {@link IRandomGenerator}\n * @returns Randomly generated data as `Resolved<T>`\n */\nexport function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;\n\n/** @internal */\nexport function random(): never {\n  NoTransformConfigurationError(\"random\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link assert} function.\n *\n * Returns a function that can be called multiple times without recompilation.\n * Useful when the same type validation is needed repeatedly.\n *\n * @template T Target type to validate against\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable assert function `(input: unknown, errorFactory?) => T`\n * @danger You must configure the generic argument `T`\n */\nexport function createAssert(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assert} function.\n *\n * Returns a function that can be called multiple times without recompilation.\n * Useful when the same type validation is needed repeatedly.\n *\n * @template T Target type to validate against\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable assert function `(input: unknown, errorFactory?) => T`,\n *   whose own `errorFactory` overrides this one for that single call\n */\nexport function createAssert<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => T;\n\n/** @internal */\nexport function createAssert<T>(): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => T {\n  NoTransformConfigurationError(\"createAssert\");\n}\n\n/**\n * Creates reusable {@link assertGuard} function.\n *\n * Returns a reusable type guard assertion function.\n *\n * TypeScript requirement: You must declare the variable type explicitly. `const\n * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.\n * That annotation is one parameter wide, so it also hides the call-time\n * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:\n * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.\n *\n * @template T Target type to validate against\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable assertion guard function\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertGuard(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertGuard} function.\n *\n * Returns a reusable type guard assertion function.\n *\n * TypeScript requirement: You must declare the variable type explicitly. `const\n * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.\n * That annotation is one parameter wide, so it also hides the call-time\n * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:\n * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.\n *\n * @template T Target type to validate against\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable assertion guard function, whose own `errorFactory`\n *   overrides this one for that single call\n */\nexport function createAssertGuard<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => asserts input is T;\n\n/** @internal */\nexport function createAssertGuard<T>(): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => asserts input is T {\n  NoTransformConfigurationError(\"createAssertGuard\");\n}\n\n/**\n * Creates reusable {@link is} function.\n *\n * Returns a type guard function that can be called multiple times without\n * recompilation.\n *\n * @template T Target type to check\n * @returns Reusable type guard function `(input: unknown) => input is T`\n * @danger You must configure the generic argument `T`\n */\nexport function createIs(): never;\n\n/**\n * Creates reusable {@link is} function.\n *\n * Returns a type guard function that can be called multiple times without\n * recompilation.\n *\n * @template T Target type to check\n * @returns Reusable type guard function `(input: unknown) => input is T`\n */\nexport function createIs<T>(): (input: unknown) => input is T;\n\n/** @internal */\nexport function createIs<T>(): (input: unknown) => input is T {\n  NoTransformConfigurationError(\"createIs\");\n}\n\n/**\n * Creates reusable {@link shallow} function.\n *\n * Returns a depth-limited type guard function that can be called multiple times\n * without recompilation.\n *\n * @template T Target type to check\n * @template N Maximum depth to descend before accepting a value structurally.\n *   Must be a non-negative integer literal. Defaults to `2`.\n * @returns Reusable type guard function `(input: unknown) => input is T`\n * @danger You must configure the generic argument `T`\n */\nexport function createShallow(): never;\n\n/**\n * Creates reusable {@link shallow} function.\n *\n * Returns a depth-limited type guard function that can be called multiple times\n * without recompilation.\n *\n * @template T Target type to check\n * @template N Maximum depth to descend before accepting a value structurally.\n *   Must be a non-negative integer literal. Defaults to `2`.\n * @returns Reusable type guard function `(input: unknown) => input is T`\n */\nexport function createShallow<T, N extends number = 2>(): (\n  input: unknown,\n) => input is T;\n\n/** @internal */\nexport function createShallow<T>(): (input: unknown) => input is T {\n  NoTransformConfigurationError(\"createShallow\");\n}\n\n/**\n * Creates reusable {@link validate} function.\n *\n * Returns a validation function that can be called multiple times without\n * recompilation. Also implements {@link StandardSchemaV1} interface for\n * interoperability.\n *\n * @template T Target type to validate against\n * @returns Reusable validate function `(input: unknown) => IValidation<T>`\n * @danger You must configure the generic argument `T`\n */\nexport function createValidate(): never;\n\n/**\n * Creates reusable {@link validate} function.\n *\n * Returns a validation function that can be called multiple times without\n * recompilation. Also implements {@link StandardSchemaV1} interface for\n * interoperability.\n *\n * @template T Target type to validate against\n * @returns Reusable validate function `(input: unknown) => IValidation<T>`\n */\nexport function createValidate<T>(): ((input: unknown) => IValidation<T>) &\n  StandardSchemaV1<T, T>;\n\n/** @internal */\nexport function createValidate(): ((input: unknown) => IValidation) &\n  StandardSchemaV1<unknown, unknown> {\n  NoTransformConfigurationError(\"createValidate\");\n}\n\n/**\n * Creates reusable {@link assertEquals} function.\n *\n * Returns a strict assertion function that rejects superfluous properties. Can\n * be called multiple times without recompilation.\n *\n * @template T Target type for exact match\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>\n *   T`\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertEquals(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertEquals} function.\n *\n * Returns a strict assertion function that rejects superfluous properties. Can\n * be called multiple times without recompilation.\n *\n * @template T Target type for exact match\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>\n *   T`, whose own `errorFactory` overrides this one for that single call\n */\nexport function createAssertEquals<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => T;\n\n/** @internal */\nexport function createAssertEquals<T>(): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => T {\n  NoTransformConfigurationError(\"createAssertEquals\");\n}\n\n/**\n * Creates reusable {@link assertGuardEquals} function.\n *\n * Returns a strict assertion guard that rejects superfluous properties.\n *\n * TypeScript requirement: You must declare the variable type explicitly. `const\n * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile\n * error. That annotation is one parameter wide, so it also hides the call-time\n * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:\n * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.\n *\n * @template T Target type for exact match\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable assertion guard function\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertGuardEquals(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertGuardEquals} function.\n *\n * Returns a strict assertion guard that rejects superfluous properties.\n *\n * TypeScript requirement: You must declare the variable type explicitly. `const\n * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile\n * error. That annotation is one parameter wide, so it also hides the call-time\n * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:\n * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.\n *\n * @template T Target type for exact match\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable assertion guard function, whose own `errorFactory`\n *   overrides this one for that single call\n */\nexport function createAssertGuardEquals<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => asserts input is T;\n\n/** @internal */\nexport function createAssertGuardEquals<T>(): (\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => asserts input is T {\n  NoTransformConfigurationError(\"createAssertGuardEquals\");\n}\n\n/**\n * Creates reusable {@link equals} function.\n *\n * Returns a strict type guard that rejects superfluous properties. Can be\n * called multiple times without recompilation.\n *\n * @template T Target type for exact match\n * @returns Reusable type guard function `(input: unknown) => input is T`\n * @danger You must configure the generic argument `T`\n */\nexport function createEquals(): never;\n\n/**\n * Creates reusable {@link equals} function.\n *\n * Returns a strict type guard that rejects superfluous properties. Can be\n * called multiple times without recompilation.\n *\n * @template T Target type for exact match\n * @returns Reusable type guard function `(input: unknown) => input is T`\n */\nexport function createEquals<T>(): (input: unknown) => input is T;\n\n/** @internal */\nexport function createEquals<T>(): (input: unknown) => input is T {\n  NoTransformConfigurationError(\"createEquals\");\n}\n\n/**\n * Creates reusable {@link validateEquals} function.\n *\n * Returns a strict validation function that rejects superfluous properties.\n * Also implements {@link StandardSchemaV1} interface for interoperability.\n *\n * @template T Target type for exact match\n * @returns Reusable validateEquals function `(input: unknown) =>\n *   IValidation<T>`\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateEquals(): never;\n\n/**\n * Creates reusable {@link validateEquals} function.\n *\n * Returns a strict validation function that rejects superfluous properties.\n * Also implements {@link StandardSchemaV1} interface for interoperability.\n *\n * @template T Target type for exact match\n * @returns Reusable validateEquals function `(input: unknown) =>\n *   IValidation<T>`\n */\nexport function createValidateEquals<T>(): ((\n  input: unknown,\n) => IValidation<T>) &\n  StandardSchemaV1<T, T>;\n\n/** @internal */\nexport function createValidateEquals(): ((input: unknown) => IValidation) &\n  StandardSchemaV1<unknown, unknown> {\n  NoTransformConfigurationError(\"createValidateEquals\");\n}\n\n/**\n * Creates reusable {@link random} function.\n *\n * Returns a random data generator that can be called multiple times without\n * recompilation.\n *\n * @template T Type of data to generate\n * @param generator Custom random generator implementing {@link IRandomGenerator}\n * @returns Reusable random function `() => Resolved<T>`\n * @danger You must configure the generic argument `T`\n */\nexport function createRandom(generator?: Partial<IRandomGenerator>): never;\n\n/**\n * Creates reusable {@link random} function.\n *\n * Returns a random data generator that can be called multiple times without\n * recompilation.\n *\n * @template T Type of data to generate\n * @param generator Custom random generator implementing {@link IRandomGenerator}\n * @returns Reusable random function `() => Resolved<T>`\n */\nexport function createRandom<T>(\n  generator?: Partial<IRandomGenerator>,\n): () => Resolved<T>;\n\n/** @internal */\nexport function createRandom(): never {\n  NoTransformConfigurationError(\"createRandom\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsFA,SAAgB,SAAgB;CAC9B,8BAA8B,QAAQ;AACxC;;AA6DA,SAAgB,cAAqB;CACnC,8BAA8B,aAAa;AAC7C;;AA2CA,SAAgB,KAAY;CAC1B,8BAA8B,IAAI;AACpC;;AAiEA,SAAgB,UAAiB;CAC/B,8BAA8B,SAAS;AACzC;;AAqDA,SAAgB,WAAkB;CAChC,8BAA8B,UAAU;AAC1C;;AA0DA,SAAgB,eAAsB;CACpC,8BAA8B,cAAc;AAC9C;;AAqDA,SAAgB,oBAA2B;CACzC,8BAA8B,mBAAmB;AACnD;;AAyCA,SAAgB,SAAgB;CAC9B,8BAA8B,QAAQ;AACxC;;AAmDA,SAAgB,iBAAwB;CACtC,8BAA8B,gBAAgB;AAChD;;AAiCA,SAAgB,SAAgB;CAC9B,8BAA8B,QAAQ;AACxC;;AAyCA,SAAgB,eAGT;CACL,8BAA8B,cAAc;AAC9C;;AAgDA,SAAgB,oBAGQ;CACtB,8BAA8B,mBAAmB;AACnD;;AA0BA,SAAgB,WAA8C;CAC5D,8BAA8B,UAAU;AAC1C;;AAgCA,SAAgB,gBAAmD;CACjE,8BAA8B,eAAe;AAC/C;;AA6BA,SAAgB,iBACqB;CACnC,8BAA8B,gBAAgB;AAChD;;AAuCA,SAAgB,qBAGT;CACL,8BAA8B,oBAAoB;AACpD;;AAgDA,SAAgB,0BAGQ;CACtB,8BAA8B,yBAAyB;AACzD;;AA0BA,SAAgB,eAAkD;CAChE,8BAA8B,cAAc;AAC9C;;AA+BA,SAAgB,uBACqB;CACnC,8BAA8B,sBAAsB;AACtD;;AA8BA,SAAgB,eAAsB;CACpC,8BAA8B,cAAc;AAC9C"}
+{"version":3,"file":"module.mjs","names":[],"sources":["../src/module.ts"],"sourcesContent":["export * as compare from \"./compare\";\nexport * as functional from \"./functional\";\nexport * as http from \"./http\";\nexport * as llm from \"./llm\";\nexport * as json from \"./json\";\nexport * as plain from \"./plain\";\nexport * as notations from \"./notations\";\nexport * as protobuf from \"./protobuf\";\nexport * as reflect from \"./reflect\";\n\nexport * from \"./TypeGuardError\";\n\nexport * from \"./re-exports\";\n\nexport * from \"./basic\";\n"],"mappings":""}

package/lib/notations.d.ts

@@ -16,8 +16,11 @@ import { TypeGuardError } from "./TypeGuardError";
  * - {@link validateCamel} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns New object with camelCase property names
+ *
  * @throws {Error} When two source keys become the same destination key
  */
 export declare function camel<T>(input: T): CamelCase<T>;
@@ -34,10 +37,13 @@ export declare function camel<T>(input: T): CamelCase<T>;
  * - {@link validateCamel} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns New object with camelCase property names
+ *
  * @throws {TypeGuardError} When input doesn't conform to type `T`
  */
 export declare function assertCamel<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): CamelCase<T>;
@@ -54,7 +60,9 @@ export declare function assertCamel<T>(input: T, errorFactory?: undefined | ((pr
  * - {@link validateCamel} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns New object with camelCase property names, or `null` if invalid
  */
 export declare function isCamel<T>(input: T): CamelCase<T> | null;
@@ -72,7 +80,9 @@ export declare function isCamel<T>(input: T): CamelCase<T> | null;
  * - {@link isCamel} — Returns `null` instead of error details
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns Validation result containing converted object or errors
  */
 export declare function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
@@ -92,8 +102,11 @@ export declare function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
  * - {@link validatePascal} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns New object with PascalCase property names
+ *
  * @throws {Error} When two source keys become the same destination key
  */
 export declare function pascal<T>(input: T): PascalCase<T>;
@@ -110,10 +123,13 @@ export declare function pascal<T>(input: T): PascalCase<T>;
  * - {@link validatePascal} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns New object with PascalCase property names
+ *
  * @throws {TypeGuardError} When input doesn't conform to type `T`
  */
 export declare function assertPascal<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): PascalCase<T>;
@@ -130,7 +146,9 @@ export declare function assertPascal<T>(input: T, errorFactory?: undefined | ((p
  * - {@link validatePascal} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns New object with PascalCase property names, or `null` if invalid
  */
 export declare function isPascal<T>(input: T): PascalCase<T> | null;
@@ -148,7 +166,9 @@ export declare function isPascal<T>(input: T): PascalCase<T> | null;
  * - {@link isPascal} — Returns `null` instead of error details
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns Validation result containing converted object or errors
  */
 export declare function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
@@ -168,8 +188,11 @@ export declare function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
  * - {@link validateSnake} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns New object with snake_case property names
+ *
  * @throws {Error} When two source keys become the same destination key
  */
 export declare function snake<T>(input: T): SnakeCase<T>;
@@ -186,10 +209,13 @@ export declare function snake<T>(input: T): SnakeCase<T>;
  * - {@link validateSnake} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns New object with snake_case property names
+ *
  * @throws {TypeGuardError} When input doesn't conform to type `T`
  */
 export declare function assertSnake<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): SnakeCase<T>;
@@ -206,7 +232,9 @@ export declare function assertSnake<T>(input: T, errorFactory?: undefined | ((pr
  * - {@link validateSnake} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns New object with snake_case property names, or `null` if invalid
  */
 export declare function isSnake<T>(input: T): SnakeCase<T> | null;
@@ -224,7 +252,9 @@ export declare function isSnake<T>(input: T): SnakeCase<T> | null;
  * - {@link isSnake} — Returns `null` instead of error details
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns Validation result containing converted object or errors
  */
 export declare function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
@@ -244,8 +274,11 @@ export declare function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
  * - {@link validateKebab} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns New object with kebab-case property names
+ *
  * @throws {Error} When two source keys become the same destination key
  */
 export declare function kebab<T>(input: T): KebabCase<T>;
@@ -262,10 +295,13 @@ export declare function kebab<T>(input: T): KebabCase<T>;
  * - {@link validateKebab} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns New object with kebab-case property names
+ *
  * @throws {TypeGuardError} When input doesn't conform to type `T`
  */
 export declare function assertKebab<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): KebabCase<T>;
@@ -282,7 +318,9 @@ export declare function assertKebab<T>(input: T, errorFactory?: undefined | ((pr
  * - {@link validateKebab} — Returns detailed validation errors
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns New object with kebab-case property names, or `null` if invalid
  */
 export declare function isKebab<T>(input: T): KebabCase<T> | null;
@@ -300,7 +338,9 @@ export declare function isKebab<T>(input: T): KebabCase<T> | null;
  * - {@link isKebab} — Returns `null` instead of error details
  *
  * @template T Type of input value
+ *
  * @param input Object to convert
+ *
  * @returns Validation result containing converted object or errors
  */
 export declare function validateKebab<T>(input: T): IValidation<KebabCase<T>>;
@@ -314,6 +354,7 @@ export declare function createCamel(): never;
  * Creates reusable {@link camel} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createCamel<T>(): (input: T) => CamelCase<T>;
@@ -327,8 +368,10 @@ export declare function createAssertCamel(errorFactory?: undefined | ((props: Ty
  * Creates reusable {@link assertCamel} function.
  *
  * @template T Type of input value
+ *
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Reusable conversion function
  */
 export declare function createAssertCamel<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)) => CamelCase<T>;
@@ -342,6 +385,7 @@ export declare function createIsCamel(): never;
  * Creates reusable {@link isCamel} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createIsCamel<T>(): (input: T) => CamelCase<T> | null;
@@ -355,6 +399,7 @@ export declare function createValidateCamel(): never;
  * Creates reusable {@link validateCamel} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createValidateCamel<T>(): (input: T) => IValidation<CamelCase<T>>;
@@ -368,6 +413,7 @@ export declare function createPascal(): never;
  * Creates reusable {@link pascal} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createPascal<T>(): (input: T) => PascalCase<T>;
@@ -381,8 +427,10 @@ export declare function createAssertPascal(errorFactory?: undefined | ((props: T
  * Creates reusable {@link assertPascal} function.
  *
  * @template T Type of input value
+ *
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Reusable conversion function
  */
 export declare function createAssertPascal<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)) => PascalCase<T>;
@@ -396,6 +444,7 @@ export declare function createIsPascal(): never;
  * Creates reusable {@link isPascal} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createIsPascal<T>(): (input: T) => PascalCase<T> | null;
@@ -409,6 +458,7 @@ export declare function createValidatePascal(): never;
  * Creates reusable {@link validatePascal} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createValidatePascal<T>(): (input: T) => IValidation<PascalCase<T>>;
@@ -422,6 +472,7 @@ export declare function createSnake(): never;
  * Creates reusable {@link snake} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createSnake<T>(): (input: T) => SnakeCase<T>;
@@ -435,8 +486,10 @@ export declare function createAssertSnake(errorFactory?: undefined | ((props: Ty
  * Creates reusable {@link assertSnake} function.
  *
  * @template T Type of input value
+ *
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Reusable conversion function
  */
 export declare function createAssertSnake<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)) => SnakeCase<T>;
@@ -450,6 +503,7 @@ export declare function createIsSnake(): never;
  * Creates reusable {@link isSnake} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;
@@ -463,6 +517,7 @@ export declare function createValidateSnake(): never;
  * Creates reusable {@link validateSnake} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createValidateSnake<T>(): (input: T) => IValidation<SnakeCase<T>>;
@@ -476,6 +531,7 @@ export declare function createKebab(): never;
  * Creates reusable {@link kebab} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createKebab<T>(): (input: T) => KebabCase<T>;
@@ -489,8 +545,10 @@ export declare function createAssertKebab(errorFactory?: undefined | ((props: Ty
  * Creates reusable {@link assertKebab} function.
  *
  * @template T Type of input value
+ *
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Reusable conversion function
  */
 export declare function createAssertKebab<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)) => KebabCase<T>;
@@ -504,6 +562,7 @@ export declare function createIsKebab(): never;
  * Creates reusable {@link isKebab} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createIsKebab<T>(): (input: T) => KebabCase<T> | null;
@@ -517,6 +576,7 @@ export declare function createValidateKebab(): never;
  * Creates reusable {@link validateKebab} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable conversion function
  */
 export declare function createValidateKebab<T>(): (input: T) => IValidation<KebabCase<T>>;

package/lib/notations.js.map

@@ -1 +1 @@
-{"version":3,"file":"notations.js","sourceRoot":"","sources":["../src/notations.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"notations.js","sourceRoot":"","sources":["../src/notations.ts"],"names":[],"mappings":"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"}