typia 13.1.1 → 13.1.19

package/lib/internal/private/__notationRename.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__notationRename.js","sourceRoot":"","sources":["../../../src/internal/private/__notationRename.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACI,MAAM,gBAAgB,GAC3B,CAAC,KAGA,EAAE,EAAE,CACL,CAAC,GAAW,EAAU,EAAE;IACtB,IAAI,MAAM,GAAW,EAAE,CAAC;IACxB,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,CAAC;QACd,GAAG,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACzB,CAAC;IACD,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IACpC,OAAO,GAAG,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;AAC/E,CAAC,CAAC;AAbS,QAAA,gBAAgB,GAAhB,gBAAgB,CAazB"}

package/lib/internal/private/__notationRename.mjs

@@ -0,0 +1,24 @@
+//#region src/internal/private/__notationRename.ts
+/**
+* Shared outer walk for the `camel`/`pascal` notations.
+*
+* Mirrors the `CamelCase<T>` / `PascalCase<T>` typings: leading underscores are
+* preserved verbatim, an all-underscore key stays untouched, and the presence
+* of any remaining underscore — not the number of non-empty segments — selects
+* the `snake` conversion. Routing on underscore presence keeps a trailing or
+* doubled underscore (`fooBar_`) on the same path the type takes, instead of
+* collapsing it to the underscore-free `plain` path.
+*/
+const __notationRename = (props) => (str) => {
+	let prefix = "";
+	while (str.startsWith("_")) {
+		prefix += "_";
+		str = str.substring(1);
+	}
+	if (str.length === 0) return prefix;
+	return `${prefix}${str.includes("_") ? props.snake(str) : props.plain(str)}`;
+};
+//#endregion
+export { __notationRename };
+
+//# sourceMappingURL=__notationRename.mjs.map

package/lib/internal/private/__notationRename.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"__notationRename.mjs","names":[],"sources":["../../../src/internal/private/__notationRename.ts"],"sourcesContent":["/**\n * Shared outer walk for the `camel`/`pascal` notations.\n *\n * Mirrors the `CamelCase<T>` / `PascalCase<T>` typings: leading underscores are\n * preserved verbatim, an all-underscore key stays untouched, and the presence\n * of any remaining underscore — not the number of non-empty segments — selects\n * the `snake` conversion. Routing on underscore presence keeps a trailing or\n * doubled underscore (`fooBar_`) on the same path the type takes, instead of\n * collapsing it to the underscore-free `plain` path.\n */\nexport const __notationRename =\n  (props: {\n    plain: (str: string) => string;\n    snake: (str: string) => string;\n  }) =>\n  (str: string): string => {\n    let prefix: string = \"\";\n    while (str.startsWith(\"_\")) {\n      prefix += \"_\";\n      str = str.substring(1);\n    }\n    if (str.length === 0) return prefix;\n    return `${prefix}${str.includes(\"_\") ? props.snake(str) : props.plain(str)}`;\n  };\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,oBACV,WAIA,QAAwB;CACvB,IAAI,SAAiB;CACrB,OAAO,IAAI,WAAW,GAAG,GAAG;EAC1B,UAAU;EACV,MAAM,IAAI,UAAU,CAAC;CACvB;CACA,IAAI,IAAI,WAAW,GAAG,OAAO;CAC7B,OAAO,GAAG,SAAS,IAAI,SAAS,GAAG,IAAI,MAAM,MAAM,GAAG,IAAI,MAAM,MAAM,GAAG;AAC3E"}

package/lib/json.d.ts

@@ -62,10 +62,10 @@ export declare function application(): never;
  *
  * - Custom LLM function calling schema formats
  * - API documentation or code generation tools
- * - Alternative LLM integrations beyond built-in providers
+ * - Alternative LLM integrations that need full JSON Schema
  *
  * For standard LLM function calling, use {@link llm.application} instead, which
- * provides provider-specific schemas (ChatGPT, Claude, Gemini, etc.).
+ * builds the LLM-optimized function schema directly.
  *
  * @template Class Target class or interface type
  * @template Version OpenAPI version (`"3.0"` | `"3.1"`). Default `"3.1"`

package/lib/json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"json.mjs","names":[],"sources":["../src/json.ts"],"sourcesContent":["import {\n  IJsonSchemaApplication,\n  IJsonSchemaCollection,\n  IJsonSchemaUnit,\n  IValidation,\n  Primitive,\n} from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* ===========================================================\n    JSON\n      - METADATA\n      - PARSE\n      - STRINGIFY\n      - FACTORY FUNCTIONS\n==============================================================\n    METADATA\n----------------------------------------------------------- */\n/**\n * Generates JSON schema for type `T`.\n *\n * @danger You must configure the generic argument `Type`\n */\nexport function schema(): never;\n\n/**\n * Generates JSON schema for type `T`.\n *\n * Creates {@link IJsonSchemaUnit} containing a main schema and shared\n * components. Named types are stored in `components` for `$ref` referencing.\n *\n * Specify OpenAPI version via `Version` generic (`\"3.0\"` or `\"3.1\"`). Default\n * is `\"3.1\"`. Key difference: `\"3.1\"` supports tuple types.\n *\n * @template Type Target type\n * @template Version OpenAPI version (`\"3.0\"` | `\"3.1\"`). Default `\"3.1\"`\n * @returns JSON schema unit\n */\nexport function schema<\n  Type extends unknown,\n  Version extends \"3.0\" | \"3.1\" = \"3.1\",\n>(): IJsonSchemaUnit<Version, Type>;\n\n/** @internal */\nexport function schema(): never {\n  NoTransformConfigurationError(\"json.schema\");\n}\n\n/**\n * Generates JSON schemas for multiple types.\n *\n * @danger You must configure the generic argument `Types`\n */\nexport function schemas(): never;\n\n/**\n * Generates JSON schemas for multiple types.\n *\n * Creates {@link IJsonSchemaCollection} containing schemas for all types in the\n * tuple. Named types are stored in `components` for `$ref` referencing.\n *\n * Specify OpenAPI version via `Version` generic (`\"3.0\"` or `\"3.1\"`). Default\n * is `\"3.1\"`. Key difference: `\"3.1\"` supports tuple types.\n *\n * @template Types Tuple of target types\n * @template Version OpenAPI version (`\"3.0\"` | `\"3.1\"`). Default `\"3.1\"`\n * @returns JSON schema collection\n */\nexport function schemas<\n  Types extends unknown[],\n  Version extends \"3.0\" | \"3.1\" = \"3.1\",\n>(): IJsonSchemaCollection<Version, Types>;\n\n/** @internal */\nexport function schemas(): never {\n  NoTransformConfigurationError(\"json.schemas\");\n}\n\n/**\n * Generates JSON function schema application.\n *\n * @danger You must configure the generic argument `Class`\n */\nexport function application(): never;\n\n/**\n * Generates JSON function schema application from class/interface.\n *\n * Creates {@link IJsonSchemaApplication} from a TypeScript class or interface,\n * generating JSON schemas for all methods, parameters, and return types.\n * Designed for building custom LLM function calling schemas.\n *\n * The returned object contains:\n *\n * - `functions`: Array of function metadata with parameter/return schemas\n * - `components`: Shared schema components for `$ref` referencing\n *\n * Use cases:\n *\n * - Custom LLM function calling schema formats\n * - API documentation or code generation tools\n * - Alternative LLM integrations beyond built-in providers\n *\n * For standard LLM function calling, use {@link llm.application} instead, which\n * provides provider-specific schemas (ChatGPT, Claude, Gemini, etc.).\n *\n * @template Class Target class or interface type\n * @template Version OpenAPI version (`\"3.0\"` | `\"3.1\"`). Default `\"3.1\"`\n * @returns JSON function schema application\n */\nexport function application<\n  Class extends object,\n  Version extends \"3.0\" | \"3.1\" = \"3.1\",\n>(): IJsonSchemaApplication<Version, Class>;\n\n/** @internal */\nexport function application(): never {\n  NoTransformConfigurationError(\"json.application\");\n}\n\n/* -----------------------------------------------------------\n    PARSE\n----------------------------------------------------------- */\n/**\n * Parses JSON string with assertion.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function assertParse(\n  input: string,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Parses JSON string with assertion.\n *\n * Combines `JSON.parse()` with {@link assert}. Throws {@link TypeGuardError} when\n * parsed value doesn't match type `T`.\n *\n * Related functions:\n *\n * - {@link isParse} — Returns `null` instead of throwing\n * - {@link validateParse} — Returns detailed validation errors\n *\n * @template T Target type for parsed value\n * @param input JSON string to parse\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Parsed value of type `T`\n * @throws {TypeGuardError} When parsed value doesn't conform to type `T`\n */\nexport function assertParse<T>(\n  input: string,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Primitive<T>;\n\n/** @internal */\nexport function assertParse<T>(): Primitive<T> {\n  NoTransformConfigurationError(\"json.assertParse\");\n}\n\n/**\n * Parses JSON string with type checking.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function isParse(input: string): never;\n\n/**\n * Parses JSON string with type checking.\n *\n * Combines `JSON.parse()` with {@link is}. Returns `null` when parsed value\n * doesn't match type `T`.\n *\n * Related functions:\n *\n * - {@link assertParse} — Throws instead of returning `null`\n * - {@link validateParse} — Returns detailed validation errors\n *\n * @template T Target type for parsed value\n * @param input JSON string to parse\n * @returns Parsed value of type `T`, or `null` if invalid\n */\nexport function isParse<T>(input: string): Primitive<T> | null;\n\n/** @internal */\nexport function isParse<T>(): Primitive<T> | null {\n  NoTransformConfigurationError(\"json.isParse\");\n}\n\n/**\n * Parses JSON string with validation.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function validateParse(input: string): never;\n\n/**\n * Parses JSON string with validation.\n *\n * Combines `JSON.parse()` with {@link validate}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with parsed value.\n *\n * Related functions:\n *\n * - {@link assertParse} — Throws on first error\n * - {@link isParse} — Returns `null` instead of error details\n *\n * @template T Target type for parsed value\n * @param input JSON string to parse\n * @returns Validation result containing parsed value or errors\n */\nexport function validateParse<T>(input: string): IValidation<Primitive<T>>;\n\n/** @internal */\nexport function validateParse<T>(): IValidation<Primitive<T>> {\n  NoTransformConfigurationError(\"json.validateParse\");\n}\n\n/* -----------------------------------------------------------\n    STRINGIFY\n----------------------------------------------------------- */\n/**\n * Converts value to JSON string (8x faster).\n *\n * Generates optimized JSON conversion code specific to type `T`, achieving ~8x\n * faster performance than native `JSON.stringify()`.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertStringify} — Throws on type mismatch\n * - {@link isStringify} — Returns `null` on type mismatch\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to stringify\n * @returns JSON string\n */\nexport function stringify<T>(input: T): string;\n\n/** @internal */\nexport function stringify(): never {\n  NoTransformConfigurationError(\"json.stringify\");\n}\n\n/**\n * Converts value to JSON string with assertion (5x faster).\n *\n * Combines {@link assert} with {@link stringify}. Throws {@link TypeGuardError}\n * when input doesn't match type `T`. Achieves ~5x faster performance than\n * native `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link isStringify} — Returns `null` instead of throwing\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to assert and stringify\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns JSON string\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertStringify<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): string;\n\n/**\n * Converts value to JSON string with assertion (5x faster).\n *\n * Combines {@link assert} with {@link stringify}. Throws {@link TypeGuardError}\n * when input doesn't match type `T`. Achieves ~5x faster performance than\n * native `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link isStringify} — Returns `null` instead of throwing\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to assert and stringify\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns JSON string\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertStringify<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): unknown;\n\n/** @internal */\nexport function assertStringify(): string {\n  NoTransformConfigurationError(\"json.assertStringify\");\n}\n\n/**\n * Converts value to JSON string with type checking (7x faster).\n *\n * Combines {@link is} with {@link stringify}. Returns `null` when input doesn't\n * match type `T`. Achieves ~7x faster performance than native\n * `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link assertStringify} — Throws instead of returning `null`\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to check and stringify\n * @returns JSON string, or `null` if type check fails\n */\nexport function isStringify<T>(input: T): string | null;\n\n/**\n * Converts value to JSON string with type checking (7x faster).\n *\n * Combines {@link is} with {@link stringify}. Returns `null` when input doesn't\n * match type `T`. Achieves ~7x faster performance than native\n * `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link assertStringify} — Throws instead of returning `null`\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to check and stringify\n * @returns JSON string, or `null` if type check fails\n */\nexport function isStringify<T>(input: unknown): string | null;\n\n/** @internal */\nexport function isStringify(): string | null {\n  NoTransformConfigurationError(\"json.isStringify\");\n}\n\n/**\n * Converts value to JSON string with validation (5x faster).\n *\n * Combines {@link validate} with {@link stringify}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with JSON string. Achieves ~5x faster performance\n * than native `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link assertStringify} — Throws on first error\n * - {@link isStringify} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Value to validate and stringify\n * @returns Validation result containing JSON string or errors\n */\nexport function validateStringify<T>(input: T): IValidation<string>;\n\n/**\n * Converts value to JSON string with validation (5x faster).\n *\n * Combines {@link validate} with {@link stringify}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with JSON string. Achieves ~5x faster performance\n * than native `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link assertStringify} — Throws on first error\n * - {@link isStringify} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Value to validate and stringify\n * @returns Validation result containing JSON string or errors\n */\nexport function validateStringify<T>(input: unknown): IValidation<string>;\n\n/** @internal */\nexport function validateStringify(): IValidation<string> {\n  NoTransformConfigurationError(\"json.validateStringify\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link isParse} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsParse(): never;\n\n/**\n * Creates reusable {@link isParse} function.\n *\n * @template T Target type for parsed value\n * @returns Reusable parser function\n */\nexport function createIsParse<T>(): (input: string) => Primitive<T> | null;\n\n/** @internal */\nexport function createIsParse<T>(): (input: string) => Primitive<T> | null {\n  NoTransformConfigurationError(\"json.createIsParse\");\n}\n\n/**\n * Creates reusable {@link assertParse} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertParse(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertParse} function.\n *\n * @template T Target type for parsed value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable parser function\n */\nexport function createAssertParse<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: string) => Primitive<T>;\n\n/** @internal */\nexport function createAssertParse<T>(): (input: string) => Primitive<T> {\n  NoTransformConfigurationError(\"json.createAssertParse\");\n}\n\n/**\n * Creates reusable {@link validateParse} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateParse(): never;\n\n/**\n * Creates reusable {@link validateParse} function.\n *\n * @template T Target type for parsed value\n * @returns Reusable parser function\n */\nexport function createValidateParse<T>(): (\n  input: string,\n) => IValidation<Primitive<T>>;\n\n/** @internal */\nexport function createValidateParse<T>(): (\n  input: string,\n) => IValidation<Primitive<T>> {\n  NoTransformConfigurationError(\"json.createValidateParse\");\n}\n\n/**\n * Creates reusable {@link stringify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createStringify(): never;\n\n/**\n * Creates reusable {@link stringify} function.\n *\n * @template T Type of input value\n * @returns Reusable stringify function\n */\nexport function createStringify<T>(): (input: T) => string;\n\n/** @internal */\nexport function createStringify<T>(): (input: T) => string {\n  NoTransformConfigurationError(\"json.createStringify\");\n}\n\n/**\n * Creates reusable {@link assertStringify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertStringify(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertStringify} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable stringify function\n */\nexport function createAssertStringify<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => string;\n\n/** @internal */\nexport function createAssertStringify(): (input: unknown) => string {\n  NoTransformConfigurationError(\"json.createAssertStringify\");\n}\n\n/**\n * Creates reusable {@link isStringify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsStringify(): never;\n\n/**\n * Creates reusable {@link isStringify} function.\n *\n * @template T Type of input value\n * @returns Reusable stringify function\n */\nexport function createIsStringify<T>(): (input: unknown) => string | null;\n\n/** @internal */\nexport function createIsStringify(): (input: unknown) => string | null {\n  NoTransformConfigurationError(\"json.createIsStringify\");\n}\n\n/**\n * Creates reusable {@link validateStringify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateStringify(): never;\n\n/**\n * Creates reusable {@link validateStringify} function.\n *\n * @template T Type of input value\n * @returns Reusable stringify function\n */\nexport function createValidateStringify<T>(): (\n  input: unknown,\n) => IValidation<string>;\n\n/** @internal */\nexport function createValidateStringify(): (\n  input: unknown,\n) => IValidation<string> {\n  NoTransformConfigurationError(\"json.createValidateStringify\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,SAAgB;CAC9B,8BAA8B,aAAa;AAC7C;;AA4BA,SAAgB,UAAiB;CAC/B,8BAA8B,cAAc;AAC9C;;AAwCA,SAAgB,cAAqB;CACnC,8BAA8B,kBAAkB;AAClD;;AAuCA,SAAgB,cAA+B;CAC7C,8BAA8B,kBAAkB;AAClD;;AA2BA,SAAgB,UAAkC;CAChD,8BAA8B,cAAc;AAC9C;;AA4BA,SAAgB,gBAA8C;CAC5D,8BAA8B,oBAAoB;AACpD;;AAwBA,SAAgB,YAAmB;CACjC,8BAA8B,gBAAgB;AAChD;;AAqDA,SAAgB,kBAA0B;CACxC,8BAA8B,sBAAsB;AACtD;;AAyCA,SAAgB,cAA6B;CAC3C,8BAA8B,kBAAkB;AAClD;;AA2CA,SAAgB,oBAAyC;CACvD,8BAA8B,wBAAwB;AACxD;;AAqBA,SAAgB,gBAA2D;CACzE,8BAA8B,oBAAoB;AACpD;;AAwBA,SAAgB,oBAAwD;CACtE,8BAA8B,wBAAwB;AACxD;;AAoBA,SAAgB,sBAEe;CAC7B,8BAA8B,0BAA0B;AAC1D;;AAkBA,SAAgB,kBAA2C;CACzD,8BAA8B,sBAAsB;AACtD;;AAwBA,SAAgB,wBAAoD;CAClE,8BAA8B,4BAA4B;AAC5D;;AAkBA,SAAgB,oBAAuD;CACrE,8BAA8B,wBAAwB;AACxD;;AAoBA,SAAgB,0BAES;CACvB,8BAA8B,8BAA8B;AAC9D"}
+{"version":3,"file":"json.mjs","names":[],"sources":["../src/json.ts"],"sourcesContent":["import {\n  IJsonSchemaApplication,\n  IJsonSchemaCollection,\n  IJsonSchemaUnit,\n  IValidation,\n  Primitive,\n} from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* ===========================================================\n    JSON\n      - METADATA\n      - PARSE\n      - STRINGIFY\n      - FACTORY FUNCTIONS\n==============================================================\n    METADATA\n----------------------------------------------------------- */\n/**\n * Generates JSON schema for type `T`.\n *\n * @danger You must configure the generic argument `Type`\n */\nexport function schema(): never;\n\n/**\n * Generates JSON schema for type `T`.\n *\n * Creates {@link IJsonSchemaUnit} containing a main schema and shared\n * components. Named types are stored in `components` for `$ref` referencing.\n *\n * Specify OpenAPI version via `Version` generic (`\"3.0\"` or `\"3.1\"`). Default\n * is `\"3.1\"`. Key difference: `\"3.1\"` supports tuple types.\n *\n * @template Type Target type\n * @template Version OpenAPI version (`\"3.0\"` | `\"3.1\"`). Default `\"3.1\"`\n * @returns JSON schema unit\n */\nexport function schema<\n  Type extends unknown,\n  Version extends \"3.0\" | \"3.1\" = \"3.1\",\n>(): IJsonSchemaUnit<Version, Type>;\n\n/** @internal */\nexport function schema(): never {\n  NoTransformConfigurationError(\"json.schema\");\n}\n\n/**\n * Generates JSON schemas for multiple types.\n *\n * @danger You must configure the generic argument `Types`\n */\nexport function schemas(): never;\n\n/**\n * Generates JSON schemas for multiple types.\n *\n * Creates {@link IJsonSchemaCollection} containing schemas for all types in the\n * tuple. Named types are stored in `components` for `$ref` referencing.\n *\n * Specify OpenAPI version via `Version` generic (`\"3.0\"` or `\"3.1\"`). Default\n * is `\"3.1\"`. Key difference: `\"3.1\"` supports tuple types.\n *\n * @template Types Tuple of target types\n * @template Version OpenAPI version (`\"3.0\"` | `\"3.1\"`). Default `\"3.1\"`\n * @returns JSON schema collection\n */\nexport function schemas<\n  Types extends unknown[],\n  Version extends \"3.0\" | \"3.1\" = \"3.1\",\n>(): IJsonSchemaCollection<Version, Types>;\n\n/** @internal */\nexport function schemas(): never {\n  NoTransformConfigurationError(\"json.schemas\");\n}\n\n/**\n * Generates JSON function schema application.\n *\n * @danger You must configure the generic argument `Class`\n */\nexport function application(): never;\n\n/**\n * Generates JSON function schema application from class/interface.\n *\n * Creates {@link IJsonSchemaApplication} from a TypeScript class or interface,\n * generating JSON schemas for all methods, parameters, and return types.\n * Designed for building custom LLM function calling schemas.\n *\n * The returned object contains:\n *\n * - `functions`: Array of function metadata with parameter/return schemas\n * - `components`: Shared schema components for `$ref` referencing\n *\n * Use cases:\n *\n * - Custom LLM function calling schema formats\n * - API documentation or code generation tools\n * - Alternative LLM integrations that need full JSON Schema\n *\n * For standard LLM function calling, use {@link llm.application} instead, which\n * builds the LLM-optimized function schema directly.\n *\n * @template Class Target class or interface type\n * @template Version OpenAPI version (`\"3.0\"` | `\"3.1\"`). Default `\"3.1\"`\n * @returns JSON function schema application\n */\nexport function application<\n  Class extends object,\n  Version extends \"3.0\" | \"3.1\" = \"3.1\",\n>(): IJsonSchemaApplication<Version, Class>;\n\n/** @internal */\nexport function application(): never {\n  NoTransformConfigurationError(\"json.application\");\n}\n\n/* -----------------------------------------------------------\n    PARSE\n----------------------------------------------------------- */\n/**\n * Parses JSON string with assertion.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function assertParse(\n  input: string,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Parses JSON string with assertion.\n *\n * Combines `JSON.parse()` with {@link assert}. Throws {@link TypeGuardError} when\n * parsed value doesn't match type `T`.\n *\n * Related functions:\n *\n * - {@link isParse} — Returns `null` instead of throwing\n * - {@link validateParse} — Returns detailed validation errors\n *\n * @template T Target type for parsed value\n * @param input JSON string to parse\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Parsed value of type `T`\n * @throws {TypeGuardError} When parsed value doesn't conform to type `T`\n */\nexport function assertParse<T>(\n  input: string,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Primitive<T>;\n\n/** @internal */\nexport function assertParse<T>(): Primitive<T> {\n  NoTransformConfigurationError(\"json.assertParse\");\n}\n\n/**\n * Parses JSON string with type checking.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function isParse(input: string): never;\n\n/**\n * Parses JSON string with type checking.\n *\n * Combines `JSON.parse()` with {@link is}. Returns `null` when parsed value\n * doesn't match type `T`.\n *\n * Related functions:\n *\n * - {@link assertParse} — Throws instead of returning `null`\n * - {@link validateParse} — Returns detailed validation errors\n *\n * @template T Target type for parsed value\n * @param input JSON string to parse\n * @returns Parsed value of type `T`, or `null` if invalid\n */\nexport function isParse<T>(input: string): Primitive<T> | null;\n\n/** @internal */\nexport function isParse<T>(): Primitive<T> | null {\n  NoTransformConfigurationError(\"json.isParse\");\n}\n\n/**\n * Parses JSON string with validation.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function validateParse(input: string): never;\n\n/**\n * Parses JSON string with validation.\n *\n * Combines `JSON.parse()` with {@link validate}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with parsed value.\n *\n * Related functions:\n *\n * - {@link assertParse} — Throws on first error\n * - {@link isParse} — Returns `null` instead of error details\n *\n * @template T Target type for parsed value\n * @param input JSON string to parse\n * @returns Validation result containing parsed value or errors\n */\nexport function validateParse<T>(input: string): IValidation<Primitive<T>>;\n\n/** @internal */\nexport function validateParse<T>(): IValidation<Primitive<T>> {\n  NoTransformConfigurationError(\"json.validateParse\");\n}\n\n/* -----------------------------------------------------------\n    STRINGIFY\n----------------------------------------------------------- */\n/**\n * Converts value to JSON string (8x faster).\n *\n * Generates optimized JSON conversion code specific to type `T`, achieving ~8x\n * faster performance than native `JSON.stringify()`.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertStringify} — Throws on type mismatch\n * - {@link isStringify} — Returns `null` on type mismatch\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to stringify\n * @returns JSON string\n */\nexport function stringify<T>(input: T): string;\n\n/** @internal */\nexport function stringify(): never {\n  NoTransformConfigurationError(\"json.stringify\");\n}\n\n/**\n * Converts value to JSON string with assertion (5x faster).\n *\n * Combines {@link assert} with {@link stringify}. Throws {@link TypeGuardError}\n * when input doesn't match type `T`. Achieves ~5x faster performance than\n * native `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link isStringify} — Returns `null` instead of throwing\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to assert and stringify\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns JSON string\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertStringify<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): string;\n\n/**\n * Converts value to JSON string with assertion (5x faster).\n *\n * Combines {@link assert} with {@link stringify}. Throws {@link TypeGuardError}\n * when input doesn't match type `T`. Achieves ~5x faster performance than\n * native `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link isStringify} — Returns `null` instead of throwing\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to assert and stringify\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns JSON string\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertStringify<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): unknown;\n\n/** @internal */\nexport function assertStringify(): string {\n  NoTransformConfigurationError(\"json.assertStringify\");\n}\n\n/**\n * Converts value to JSON string with type checking (7x faster).\n *\n * Combines {@link is} with {@link stringify}. Returns `null` when input doesn't\n * match type `T`. Achieves ~7x faster performance than native\n * `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link assertStringify} — Throws instead of returning `null`\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to check and stringify\n * @returns JSON string, or `null` if type check fails\n */\nexport function isStringify<T>(input: T): string | null;\n\n/**\n * Converts value to JSON string with type checking (7x faster).\n *\n * Combines {@link is} with {@link stringify}. Returns `null` when input doesn't\n * match type `T`. Achieves ~7x faster performance than native\n * `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link assertStringify} — Throws instead of returning `null`\n * - {@link validateStringify} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to check and stringify\n * @returns JSON string, or `null` if type check fails\n */\nexport function isStringify<T>(input: unknown): string | null;\n\n/** @internal */\nexport function isStringify(): string | null {\n  NoTransformConfigurationError(\"json.isStringify\");\n}\n\n/**\n * Converts value to JSON string with validation (5x faster).\n *\n * Combines {@link validate} with {@link stringify}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with JSON string. Achieves ~5x faster performance\n * than native `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link assertStringify} — Throws on first error\n * - {@link isStringify} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Value to validate and stringify\n * @returns Validation result containing JSON string or errors\n */\nexport function validateStringify<T>(input: T): IValidation<string>;\n\n/**\n * Converts value to JSON string with validation (5x faster).\n *\n * Combines {@link validate} with {@link stringify}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with JSON string. Achieves ~5x faster performance\n * than native `JSON.stringify()`.\n *\n * Related functions:\n *\n * - {@link stringify} — No validation\n * - {@link assertStringify} — Throws on first error\n * - {@link isStringify} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Value to validate and stringify\n * @returns Validation result containing JSON string or errors\n */\nexport function validateStringify<T>(input: unknown): IValidation<string>;\n\n/** @internal */\nexport function validateStringify(): IValidation<string> {\n  NoTransformConfigurationError(\"json.validateStringify\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link isParse} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsParse(): never;\n\n/**\n * Creates reusable {@link isParse} function.\n *\n * @template T Target type for parsed value\n * @returns Reusable parser function\n */\nexport function createIsParse<T>(): (input: string) => Primitive<T> | null;\n\n/** @internal */\nexport function createIsParse<T>(): (input: string) => Primitive<T> | null {\n  NoTransformConfigurationError(\"json.createIsParse\");\n}\n\n/**\n * Creates reusable {@link assertParse} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertParse(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertParse} function.\n *\n * @template T Target type for parsed value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable parser function\n */\nexport function createAssertParse<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: string) => Primitive<T>;\n\n/** @internal */\nexport function createAssertParse<T>(): (input: string) => Primitive<T> {\n  NoTransformConfigurationError(\"json.createAssertParse\");\n}\n\n/**\n * Creates reusable {@link validateParse} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateParse(): never;\n\n/**\n * Creates reusable {@link validateParse} function.\n *\n * @template T Target type for parsed value\n * @returns Reusable parser function\n */\nexport function createValidateParse<T>(): (\n  input: string,\n) => IValidation<Primitive<T>>;\n\n/** @internal */\nexport function createValidateParse<T>(): (\n  input: string,\n) => IValidation<Primitive<T>> {\n  NoTransformConfigurationError(\"json.createValidateParse\");\n}\n\n/**\n * Creates reusable {@link stringify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createStringify(): never;\n\n/**\n * Creates reusable {@link stringify} function.\n *\n * @template T Type of input value\n * @returns Reusable stringify function\n */\nexport function createStringify<T>(): (input: T) => string;\n\n/** @internal */\nexport function createStringify<T>(): (input: T) => string {\n  NoTransformConfigurationError(\"json.createStringify\");\n}\n\n/**\n * Creates reusable {@link assertStringify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertStringify(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertStringify} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable stringify function\n */\nexport function createAssertStringify<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => string;\n\n/** @internal */\nexport function createAssertStringify(): (input: unknown) => string {\n  NoTransformConfigurationError(\"json.createAssertStringify\");\n}\n\n/**\n * Creates reusable {@link isStringify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsStringify(): never;\n\n/**\n * Creates reusable {@link isStringify} function.\n *\n * @template T Type of input value\n * @returns Reusable stringify function\n */\nexport function createIsStringify<T>(): (input: unknown) => string | null;\n\n/** @internal */\nexport function createIsStringify(): (input: unknown) => string | null {\n  NoTransformConfigurationError(\"json.createIsStringify\");\n}\n\n/**\n * Creates reusable {@link validateStringify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateStringify(): never;\n\n/**\n * Creates reusable {@link validateStringify} function.\n *\n * @template T Type of input value\n * @returns Reusable stringify function\n */\nexport function createValidateStringify<T>(): (\n  input: unknown,\n) => IValidation<string>;\n\n/** @internal */\nexport function createValidateStringify(): (\n  input: unknown,\n) => IValidation<string> {\n  NoTransformConfigurationError(\"json.createValidateStringify\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,SAAgB;CAC9B,8BAA8B,aAAa;AAC7C;;AA4BA,SAAgB,UAAiB;CAC/B,8BAA8B,cAAc;AAC9C;;AAwCA,SAAgB,cAAqB;CACnC,8BAA8B,kBAAkB;AAClD;;AAuCA,SAAgB,cAA+B;CAC7C,8BAA8B,kBAAkB;AAClD;;AA2BA,SAAgB,UAAkC;CAChD,8BAA8B,cAAc;AAC9C;;AA4BA,SAAgB,gBAA8C;CAC5D,8BAA8B,oBAAoB;AACpD;;AAwBA,SAAgB,YAAmB;CACjC,8BAA8B,gBAAgB;AAChD;;AAqDA,SAAgB,kBAA0B;CACxC,8BAA8B,sBAAsB;AACtD;;AAyCA,SAAgB,cAA6B;CAC3C,8BAA8B,kBAAkB;AAClD;;AA2CA,SAAgB,oBAAyC;CACvD,8BAA8B,wBAAwB;AACxD;;AAqBA,SAAgB,gBAA2D;CACzE,8BAA8B,oBAAoB;AACpD;;AAwBA,SAAgB,oBAAwD;CACtE,8BAA8B,wBAAwB;AACxD;;AAoBA,SAAgB,sBAEe;CAC7B,8BAA8B,0BAA0B;AAC1D;;AAkBA,SAAgB,kBAA2C;CACzD,8BAA8B,sBAAsB;AACtD;;AAwBA,SAAgB,wBAAoD;CAClE,8BAA8B,4BAA4B;AAC5D;;AAkBA,SAAgB,oBAAuD;CACrE,8BAA8B,wBAAwB;AACxD;;AAoBA,SAAgB,0BAES;CACvB,8BAA8B,8BAA8B;AAC9D"}

package/lib/module.d.ts

@@ -504,7 +504,7 @@ export declare function createAssertGuard(errorFactory?: undefined | ((props: Ty
  *   {@link TypeGuardError.IProps}
  * @returns Reusable assertion guard function
  */
-export declare function createAssertGuard<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => AssertionGuard<T>;
+export declare function createAssertGuard<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): AssertionGuard<T>;
 /**
  * Creates reusable {@link is} function.
  *
@@ -629,7 +629,7 @@ export declare function createAssertGuardEquals(errorFactory?: undefined | ((pro
  *   {@link TypeGuardError.IProps}
  * @returns Reusable assertion guard function
  */
-export declare function createAssertGuardEquals<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => AssertionGuard<T>;
+export declare function createAssertGuardEquals<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): AssertionGuard<T>;
 /**
  * Creates reusable {@link equals} function.
  *

package/lib/module.js.map

@@ -1 +1 @@
-{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,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;AAoCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAqCD,gBAAgB;AAChB;IACE,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;AAiCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,oBAAoB,CAAC,CAAC;AACtD,CAAC;AAuCD,gBAAgB;AAChB;IAGE,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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,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;AAoCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAqCD,gBAAgB;AAChB;IACE,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;AAiCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,oBAAoB,CAAC,CAAC;AACtD,CAAC;AAuCD,gBAAgB;AAChB;IACE,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"}

package/lib/module.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"module.mjs","names":[],"sources":["../src/module.ts"],"sourcesContent":["import { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport {\n  AssertionGuard,\n  IRandomGenerator,\n  IValidation,\n  Resolved,\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) => 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) => T`\n */\nexport function createAssert<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => T;\n\n/** @internal */\nexport function createAssert<T>(): (input: unknown) => 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 *\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 *\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 */\nexport function createAssertGuard<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => AssertionGuard<T>;\n\n/** @internal */\nexport function createAssertGuard<T>(): (input: unknown) => AssertionGuard<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) => 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) => T`\n */\nexport function createAssertEquals<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => T;\n\n/** @internal */\nexport function createAssertEquals<T>(): (input: unknown) => 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.\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.\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 */\nexport function createAssertGuardEquals<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => AssertionGuard<T>;\n\n/** @internal */\nexport function createAssertGuardEquals<T>(): (\n  input: unknown,\n) => AssertionGuard<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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuFA,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;;AAqCA,SAAgB,eAAyC;CACvD,8BAA8B,cAAc;AAC9C;;AAsCA,SAAgB,oBAA8D;CAC5E,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;;AAkCA,SAAgB,qBAA+C;CAC7D,8BAA8B,oBAAoB;AACpD;;AAwCA,SAAgB,0BAEO;CACrB,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":["import { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport {\n  AssertionGuard,\n  IRandomGenerator,\n  IValidation,\n  Resolved,\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) => 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) => T`\n */\nexport function createAssert<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => T;\n\n/** @internal */\nexport function createAssert<T>(): (input: unknown) => 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 *\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 *\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 */\nexport function createAssertGuard<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): AssertionGuard<T>;\n\n/** @internal */\nexport function createAssertGuard<T>(): AssertionGuard<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) => 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) => T`\n */\nexport function createAssertEquals<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => T;\n\n/** @internal */\nexport function createAssertEquals<T>(): (input: unknown) => 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.\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.\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 */\nexport function createAssertGuardEquals<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): AssertionGuard<T>;\n\n/** @internal */\nexport function createAssertGuardEquals<T>(): AssertionGuard<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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuFA,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;;AAqCA,SAAgB,eAAyC;CACvD,8BAA8B,cAAc;AAC9C;;AAsCA,SAAgB,oBAA0C;CACxD,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;;AAkCA,SAAgB,qBAA+C;CAC7D,8BAA8B,oBAAoB;AACpD;;AAwCA,SAAgB,0BAAgD;CAC9D,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"}

package/lib/notations.d.ts

@@ -4,7 +4,10 @@ import { TypeGuardError } from "./TypeGuardError";
  * Converts property names to camelCase.
  *
  * Transforms all property names in the object (including nested) to camelCase
- * convention. Creates a new object with renamed properties.
+ * convention. Creates a new object with renamed properties. Distinct source
+ * keys that become the same destination key are rejected with an error instead
+ * of silently discarding a value. This collision policy also applies to the
+ * assert, is, validate, and factory variants.
  *
  * Does not validate the input. For validation, use:
  *
@@ -15,6 +18,7 @@ import { TypeGuardError } from "./TypeGuardError";
  * @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>;
 /**
@@ -76,7 +80,10 @@ export declare function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
  * Converts property names to PascalCase.
  *
  * Transforms all property names in the object (including nested) to PascalCase
- * convention. Creates a new object with renamed properties.
+ * convention. Creates a new object with renamed properties. Distinct source
+ * keys that become the same destination key are rejected with an error instead
+ * of silently discarding a value. This collision policy also applies to the
+ * assert, is, validate, and factory variants.
  *
  * Does not validate the input. For validation, use:
  *
@@ -87,6 +94,7 @@ export declare function validateCamel<T>(input: T): IValidation<CamelCase<T>>;
  * @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>;
 /**
@@ -148,7 +156,10 @@ export declare function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
  * Converts property names to snake_case.
  *
  * Transforms all property names in the object (including nested) to snake_case
- * convention. Creates a new object with renamed properties.
+ * convention. Creates a new object with renamed properties. Distinct source
+ * keys that become the same destination key are rejected with an error instead
+ * of silently discarding a value. This collision policy also applies to the
+ * assert, is, validate, and factory variants.
  *
  * Does not validate the input. For validation, use:
  *
@@ -159,6 +170,7 @@ export declare function validatePascal<T>(input: T): IValidation<PascalCase<T>>;
  * @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>;
 /**
@@ -220,7 +232,10 @@ export declare function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
  * Converts property names to kebab-case.
  *
  * Transforms all property names in the object (including nested) to kebab-case
- * convention. Creates a new object with renamed properties.
+ * convention. Creates a new object with renamed properties. Distinct source
+ * keys that become the same destination key are rejected with an error instead
+ * of silently discarding a value. This collision policy also applies to the
+ * assert, is, validate, and factory variants.
  *
  * Does not validate the input. For validation, use:
  *
@@ -231,6 +246,7 @@ export declare function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;
  * @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>;
 /**

package/lib/notations.js.map

@@ -1 +1 @@
-{"version":3,"file":"notations.js","sourceRoot":"","sources":["../src/notations.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,gGAA6F;AA8B7F,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AAC1D,CAAC;AAgCD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AAChE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AAC5D,CAAC;AAwBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAClE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AAC3D,CAAC;AAgCD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,wBAAwB,CAAC,CAAC;AACjE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,oBAAoB,CAAC,CAAC;AAC7D,CAAC;AAwBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,0BAA0B,CAAC,CAAC;AACnE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AAC1D,CAAC;AAgCD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AAChE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AAC5D,CAAC;AAwBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAClE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AAC1D,CAAC;AAgCD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AAChE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AAC5D,CAAC;AAwBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAClE,CAAC;AAoBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAuBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,wBAAwB,CAAC,CAAC;AAC1D,CAAC;AAuBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,8BAA8B,CAAC,CAAC;AAChE,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,0BAA0B,CAAC,CAAC;AAC5D,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gCAAgC,CAAC,CAAC;AAClE,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAuBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAuBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC"}
+{"version":3,"file":"notations.js","sourceRoot":"","sources":["../src/notations.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,gGAA6F;AAkC7F,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AAC1D,CAAC;AAgCD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AAChE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AAC5D,CAAC;AAwBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAClE,CAAC;AA2BD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AAC3D,CAAC;AAgCD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,wBAAwB,CAAC,CAAC;AACjE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,oBAAoB,CAAC,CAAC;AAC7D,CAAC;AAwBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,0BAA0B,CAAC,CAAC;AACnE,CAAC;AA2BD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AAC1D,CAAC;AAgCD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AAChE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AAC5D,CAAC;AAwBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAClE,CAAC;AA2BD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AAC1D,CAAC;AAgCD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AAChE,CAAC;AAuBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AAC5D,CAAC;AAwBD,gBAAgB;AAChB;IACE,OAAO,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAClE,CAAC;AAoBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAuBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,wBAAwB,CAAC,CAAC;AAC1D,CAAC;AAuBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,8BAA8B,CAAC,CAAC;AAChE,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,0BAA0B,CAAC,CAAC;AAC5D,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gCAAgC,CAAC,CAAC;AAClE,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAuBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAuBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC"}

package/lib/notations.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"notations.mjs","names":[],"sources":["../src/notations.ts"],"sourcesContent":["import {\n  CamelCase,\n  IValidation,\n  KebabCase,\n  PascalCase,\n  SnakeCase,\n} from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* ===========================================================\n    NOTATIONS (NAMING CONVENTIONS)\n      - CAMEL CASE\n      - PASCAL CASE\n      - SNAKE CASE\n      - KEBAB CASE\n      - FACTORY FUNCTIONS\n==============================================================\n    CAMEL CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to camelCase.\n *\n * Transforms all property names in the object (including nested) to camelCase\n * convention. Creates a new object with renamed properties.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertCamel} — Throws on type mismatch\n * - {@link isCamel} — Returns `null` on type mismatch\n * - {@link validateCamel} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with camelCase property names\n */\nexport function camel<T>(input: T): CamelCase<T>;\n\n/** @internal */\nexport function camel(): never {\n  return NoTransformConfigurationError(\"notations.camel\");\n}\n\n/**\n * Converts property names to camelCase with assertion.\n *\n * Transforms all property names to camelCase with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link camel} — No validation\n * - {@link isCamel} — Returns `null` instead of throwing\n * - {@link validateCamel} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with camelCase property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertCamel<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): CamelCase<T>;\n\n/** @internal */\nexport function assertCamel<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): CamelCase<T>;\n\n/** @internal */\nexport function assertCamel(): never {\n  return NoTransformConfigurationError(\"notations.assertCamel\");\n}\n\n/**\n * Converts property names to camelCase with type checking.\n *\n * Transforms all property names to camelCase with {@link is} validation. Returns\n * `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link camel} — No validation\n * - {@link assertCamel} — Throws instead of returning `null`\n * - {@link validateCamel} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with camelCase property names, or `null` if invalid\n */\nexport function isCamel<T>(input: T): CamelCase<T> | null;\n\n/** @internal */\nexport function isCamel<T>(input: unknown): CamelCase<T> | null;\n\n/** @internal */\nexport function isCamel(): never {\n  return NoTransformConfigurationError(\"notations.isCamel\");\n}\n\n/**\n * Converts property names to camelCase with validation.\n *\n * Transforms all property names to camelCase with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link camel} — No validation\n * - {@link assertCamel} — Throws on first error\n * - {@link isCamel} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validateCamel<T>(input: T): IValidation<CamelCase<T>>;\n\n/** @internal */\nexport function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;\n\n/** @internal */\nexport function validateCamel(): never {\n  return NoTransformConfigurationError(\"notations.validateCamel\");\n}\n\n/* -----------------------------------------------------------\n    PASCAL CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to PascalCase.\n *\n * Transforms all property names in the object (including nested) to PascalCase\n * convention. Creates a new object with renamed properties.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertPascal} — Throws on type mismatch\n * - {@link isPascal} — Returns `null` on type mismatch\n * - {@link validatePascal} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with PascalCase property names\n */\nexport function pascal<T>(input: T): PascalCase<T>;\n\n/** @internal */\nexport function pascal(): never {\n  return NoTransformConfigurationError(\"notations.pascal\");\n}\n\n/**\n * Converts property names to PascalCase with assertion.\n *\n * Transforms all property names to PascalCase with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link pascal} — No validation\n * - {@link isPascal} — Returns `null` instead of throwing\n * - {@link validatePascal} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with PascalCase property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertPascal<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): PascalCase<T>;\n\n/** @internal */\nexport function assertPascal<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): PascalCase<T>;\n\n/** @internal */\nexport function assertPascal(): never {\n  return NoTransformConfigurationError(\"notations.assertPascal\");\n}\n\n/**\n * Converts property names to PascalCase with type checking.\n *\n * Transforms all property names to PascalCase with {@link is} validation.\n * Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link pascal} — No validation\n * - {@link assertPascal} — Throws instead of returning `null`\n * - {@link validatePascal} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with PascalCase property names, or `null` if invalid\n */\nexport function isPascal<T>(input: T): PascalCase<T> | null;\n\n/** @internal */\nexport function isPascal<T>(input: unknown): PascalCase<T> | null;\n\n/** @internal */\nexport function isPascal(): never {\n  return NoTransformConfigurationError(\"notations.isPascal\");\n}\n\n/**\n * Converts property names to PascalCase with validation.\n *\n * Transforms all property names to PascalCase with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link pascal} — No validation\n * - {@link assertPascal} — Throws on first error\n * - {@link isPascal} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validatePascal<T>(input: T): IValidation<PascalCase<T>>;\n\n/** @internal */\nexport function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;\n\n/** @internal */\nexport function validatePascal(): never {\n  return NoTransformConfigurationError(\"notations.validatePascal\");\n}\n\n/* -----------------------------------------------------------\n    SNAKE CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to snake_case.\n *\n * Transforms all property names in the object (including nested) to snake_case\n * convention. Creates a new object with renamed properties.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertSnake} — Throws on type mismatch\n * - {@link isSnake} — Returns `null` on type mismatch\n * - {@link validateSnake} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with snake_case property names\n */\nexport function snake<T>(input: T): SnakeCase<T>;\n\n/** @internal */\nexport function snake(): never {\n  return NoTransformConfigurationError(\"notations.snake\");\n}\n\n/**\n * Converts property names to snake_case with assertion.\n *\n * Transforms all property names to snake_case with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link snake} — No validation\n * - {@link isSnake} — Returns `null` instead of throwing\n * - {@link validateSnake} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with snake_case property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertSnake<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): SnakeCase<T>;\n\n/** @internal */\nexport function assertSnake<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): SnakeCase<T>;\n\n/** @internal */\nexport function assertSnake(): never {\n  return NoTransformConfigurationError(\"notations.assertSnake\");\n}\n\n/**\n * Converts property names to snake_case with type checking.\n *\n * Transforms all property names to snake_case with {@link is} validation.\n * Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link snake} — No validation\n * - {@link assertSnake} — Throws instead of returning `null`\n * - {@link validateSnake} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with snake_case property names, or `null` if invalid\n */\nexport function isSnake<T>(input: T): SnakeCase<T> | null;\n\n/** @internal */\nexport function isSnake<T>(input: unknown): SnakeCase<T> | null;\n\n/** @internal */\nexport function isSnake(): never {\n  return NoTransformConfigurationError(\"notations.isSnake\");\n}\n\n/**\n * Converts property names to snake_case with validation.\n *\n * Transforms all property names to snake_case with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link snake} — No validation\n * - {@link assertSnake} — Throws on first error\n * - {@link isSnake} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;\n\n/** @internal */\nexport function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;\n\n/** @internal */\nexport function validateSnake(): never {\n  return NoTransformConfigurationError(\"notations.validateSnake\");\n}\n\n/* -----------------------------------------------------------\n    KEBAB CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to kebab-case.\n *\n * Transforms all property names in the object (including nested) to kebab-case\n * convention. Creates a new object with renamed properties.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertKebab} — Throws on type mismatch\n * - {@link isKebab} — Returns `null` on type mismatch\n * - {@link validateKebab} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with kebab-case property names\n */\nexport function kebab<T>(input: T): KebabCase<T>;\n\n/** @internal */\nexport function kebab(): never {\n  return NoTransformConfigurationError(\"notations.kebab\");\n}\n\n/**\n * Converts property names to kebab-case with assertion.\n *\n * Transforms all property names to kebab-case with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link kebab} — No validation\n * - {@link isKebab} — Returns `null` instead of throwing\n * - {@link validateKebab} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with kebab-case property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertKebab<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): KebabCase<T>;\n\n/** @internal */\nexport function assertKebab<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): KebabCase<T>;\n\n/** @internal */\nexport function assertKebab(): never {\n  return NoTransformConfigurationError(\"notations.assertKebab\");\n}\n\n/**\n * Converts property names to kebab-case with type checking.\n *\n * Transforms all property names to kebab-case with {@link is} validation.\n * Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link kebab} — No validation\n * - {@link assertKebab} — Throws instead of returning `null`\n * - {@link validateKebab} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with kebab-case property names, or `null` if invalid\n */\nexport function isKebab<T>(input: T): KebabCase<T> | null;\n\n/** @internal */\nexport function isKebab<T>(input: unknown): KebabCase<T> | null;\n\n/** @internal */\nexport function isKebab(): never {\n  return NoTransformConfigurationError(\"notations.isKebab\");\n}\n\n/**\n * Converts property names to kebab-case with validation.\n *\n * Transforms all property names to kebab-case with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link kebab} — No validation\n * - {@link assertKebab} — Throws on first error\n * - {@link isKebab} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validateKebab<T>(input: T): IValidation<KebabCase<T>>;\n\n/** @internal */\nexport function validateKebab<T>(input: unknown): IValidation<KebabCase<T>>;\n\n/** @internal */\nexport function validateKebab(): never {\n  return NoTransformConfigurationError(\"notations.validateKebab\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link camel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createCamel(): never;\n\n/**\n * Creates reusable {@link camel} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createCamel<T>(): (input: T) => CamelCase<T>;\n\n/** @internal */\nexport function createCamel(): never {\n  NoTransformConfigurationError(\"notations.createCamel\");\n}\n\n/**\n * Creates reusable {@link assertCamel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertCamel(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertCamel} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertCamel<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => CamelCase<T>;\n\n/** @internal */\nexport function createAssertCamel(): never {\n  NoTransformConfigurationError(\"notations.createAssertCamel\");\n}\n\n/**\n * Creates reusable {@link isCamel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsCamel(): never;\n\n/**\n * Creates reusable {@link isCamel} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsCamel<T>(): (input: T) => CamelCase<T> | null;\n\n/** @internal */\nexport function createIsCamel(): never {\n  NoTransformConfigurationError(\"notations.createIsCamel\");\n}\n\n/**\n * Creates reusable {@link validateCamel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateCamel(): never;\n\n/**\n * Creates reusable {@link validateCamel} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidateCamel<T>(): (\n  input: T,\n) => IValidation<CamelCase<T>>;\n\n/** @internal */\nexport function createValidateCamel(): never {\n  NoTransformConfigurationError(\"notations.createValidateCamel\");\n}\n\n/**\n * Creates reusable {@link pascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createPascal(): never;\n\n/**\n * Creates reusable {@link pascal} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createPascal<T>(): (input: T) => PascalCase<T>;\n\n/** @internal */\nexport function createPascal(): never {\n  NoTransformConfigurationError(\"notations.createPascal\");\n}\n\n/**\n * Creates reusable {@link assertPascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertPascal(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertPascal} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertPascal<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => PascalCase<T>;\n\n/** @internal */\nexport function createAssertPascal(): never {\n  NoTransformConfigurationError(\"notations.createAssertPascal\");\n}\n\n/**\n * Creates reusable {@link isPascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsPascal(): never;\n\n/**\n * Creates reusable {@link isPascal} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsPascal<T>(): (input: T) => PascalCase<T> | null;\n\n/** @internal */\nexport function createIsPascal(): never {\n  NoTransformConfigurationError(\"notations.createIsPascal\");\n}\n\n/**\n * Creates reusable {@link validatePascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidatePascal(): never;\n\n/**\n * Creates reusable {@link validatePascal} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidatePascal<T>(): (\n  input: T,\n) => IValidation<PascalCase<T>>;\n\n/** @internal */\nexport function createValidatePascal(): never {\n  NoTransformConfigurationError(\"notations.createValidatePascal\");\n}\n\n/**\n * Creates reusable {@link snake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createSnake(): never;\n\n/**\n * Creates reusable {@link snake} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createSnake<T>(): (input: T) => SnakeCase<T>;\n\n/** @internal */\nexport function createSnake(): never {\n  NoTransformConfigurationError(\"notations.createSnake\");\n}\n\n/**\n * Creates reusable {@link assertSnake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertSnake(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertSnake} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertSnake<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => SnakeCase<T>;\n\n/** @internal */\nexport function createAssertSnake(): never {\n  NoTransformConfigurationError(\"notations.createAssertSnake\");\n}\n\n/**\n * Creates reusable {@link isSnake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsSnake(): never;\n\n/**\n * Creates reusable {@link isSnake} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;\n\n/** @internal */\nexport function createIsSnake(): never {\n  NoTransformConfigurationError(\"notations.createIsSnake\");\n}\n\n/**\n * Creates reusable {@link validateSnake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateSnake(): never;\n\n/**\n * Creates reusable {@link validateSnake} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidateSnake<T>(): (\n  input: T,\n) => IValidation<SnakeCase<T>>;\n\n/** @internal */\nexport function createValidateSnake(): never {\n  NoTransformConfigurationError(\"notations.createValidateSnake\");\n}\n\n/**\n * Creates reusable {@link kebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createKebab(): never;\n\n/**\n * Creates reusable {@link kebab} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createKebab<T>(): (input: T) => KebabCase<T>;\n\n/** @internal */\nexport function createKebab(): never {\n  NoTransformConfigurationError(\"notations.createKebab\");\n}\n\n/**\n * Creates reusable {@link assertKebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertKebab(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertKebab} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertKebab<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => KebabCase<T>;\n\n/** @internal */\nexport function createAssertKebab(): never {\n  NoTransformConfigurationError(\"notations.createAssertKebab\");\n}\n\n/**\n * Creates reusable {@link isKebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsKebab(): never;\n\n/**\n * Creates reusable {@link isKebab} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsKebab<T>(): (input: T) => KebabCase<T> | null;\n\n/** @internal */\nexport function createIsKebab(): never {\n  NoTransformConfigurationError(\"notations.createIsKebab\");\n}\n\n/**\n * Creates reusable {@link validateKebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateKebab(): never;\n\n/**\n * Creates reusable {@link validateKebab} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidateKebab<T>(): (\n  input: T,\n) => IValidation<KebabCase<T>>;\n\n/** @internal */\nexport function createValidateKebab(): never {\n  NoTransformConfigurationError(\"notations.createValidateKebab\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,QAAe;CAC7B,OAAO,8BAA8B,iBAAiB;AACxD;;AAiCA,SAAgB,cAAqB;CACnC,OAAO,8BAA8B,uBAAuB;AAC9D;;AAwBA,SAAgB,UAAiB;CAC/B,OAAO,8BAA8B,mBAAmB;AAC1D;;AAyBA,SAAgB,gBAAuB;CACrC,OAAO,8BAA8B,yBAAyB;AAChE;;AAwBA,SAAgB,SAAgB;CAC9B,OAAO,8BAA8B,kBAAkB;AACzD;;AAiCA,SAAgB,eAAsB;CACpC,OAAO,8BAA8B,wBAAwB;AAC/D;;AAwBA,SAAgB,WAAkB;CAChC,OAAO,8BAA8B,oBAAoB;AAC3D;;AAyBA,SAAgB,iBAAwB;CACtC,OAAO,8BAA8B,0BAA0B;AACjE;;AAwBA,SAAgB,QAAe;CAC7B,OAAO,8BAA8B,iBAAiB;AACxD;;AAiCA,SAAgB,cAAqB;CACnC,OAAO,8BAA8B,uBAAuB;AAC9D;;AAwBA,SAAgB,UAAiB;CAC/B,OAAO,8BAA8B,mBAAmB;AAC1D;;AAyBA,SAAgB,gBAAuB;CACrC,OAAO,8BAA8B,yBAAyB;AAChE;;AAwBA,SAAgB,QAAe;CAC7B,OAAO,8BAA8B,iBAAiB;AACxD;;AAiCA,SAAgB,cAAqB;CACnC,OAAO,8BAA8B,uBAAuB;AAC9D;;AAwBA,SAAgB,UAAiB;CAC/B,OAAO,8BAA8B,mBAAmB;AAC1D;;AAyBA,SAAgB,gBAAuB;CACrC,OAAO,8BAA8B,yBAAyB;AAChE;;AAqBA,SAAgB,cAAqB;CACnC,8BAA8B,uBAAuB;AACvD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,6BAA6B;AAC7D;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,+BAA+B;AAC/D;;AAkBA,SAAgB,eAAsB;CACpC,8BAA8B,wBAAwB;AACxD;;AAwBA,SAAgB,qBAA4B;CAC1C,8BAA8B,8BAA8B;AAC9D;;AAkBA,SAAgB,iBAAwB;CACtC,8BAA8B,0BAA0B;AAC1D;;AAoBA,SAAgB,uBAA8B;CAC5C,8BAA8B,gCAAgC;AAChE;;AAkBA,SAAgB,cAAqB;CACnC,8BAA8B,uBAAuB;AACvD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,6BAA6B;AAC7D;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,+BAA+B;AAC/D;;AAkBA,SAAgB,cAAqB;CACnC,8BAA8B,uBAAuB;AACvD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,6BAA6B;AAC7D;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,+BAA+B;AAC/D"}
+{"version":3,"file":"notations.mjs","names":[],"sources":["../src/notations.ts"],"sourcesContent":["import {\n  CamelCase,\n  IValidation,\n  KebabCase,\n  PascalCase,\n  SnakeCase,\n} from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* ===========================================================\n    NOTATIONS (NAMING CONVENTIONS)\n      - CAMEL CASE\n      - PASCAL CASE\n      - SNAKE CASE\n      - KEBAB CASE\n      - FACTORY FUNCTIONS\n==============================================================\n    CAMEL CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to camelCase.\n *\n * Transforms all property names in the object (including nested) to camelCase\n * convention. Creates a new object with renamed properties. Distinct source\n * keys that become the same destination key are rejected with an error instead\n * of silently discarding a value. This collision policy also applies to the\n * assert, is, validate, and factory variants.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertCamel} — Throws on type mismatch\n * - {@link isCamel} — Returns `null` on type mismatch\n * - {@link validateCamel} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with camelCase property names\n * @throws {Error} When two source keys become the same destination key\n */\nexport function camel<T>(input: T): CamelCase<T>;\n\n/** @internal */\nexport function camel(): never {\n  return NoTransformConfigurationError(\"notations.camel\");\n}\n\n/**\n * Converts property names to camelCase with assertion.\n *\n * Transforms all property names to camelCase with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link camel} — No validation\n * - {@link isCamel} — Returns `null` instead of throwing\n * - {@link validateCamel} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with camelCase property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertCamel<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): CamelCase<T>;\n\n/** @internal */\nexport function assertCamel<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): CamelCase<T>;\n\n/** @internal */\nexport function assertCamel(): never {\n  return NoTransformConfigurationError(\"notations.assertCamel\");\n}\n\n/**\n * Converts property names to camelCase with type checking.\n *\n * Transforms all property names to camelCase with {@link is} validation. Returns\n * `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link camel} — No validation\n * - {@link assertCamel} — Throws instead of returning `null`\n * - {@link validateCamel} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with camelCase property names, or `null` if invalid\n */\nexport function isCamel<T>(input: T): CamelCase<T> | null;\n\n/** @internal */\nexport function isCamel<T>(input: unknown): CamelCase<T> | null;\n\n/** @internal */\nexport function isCamel(): never {\n  return NoTransformConfigurationError(\"notations.isCamel\");\n}\n\n/**\n * Converts property names to camelCase with validation.\n *\n * Transforms all property names to camelCase with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link camel} — No validation\n * - {@link assertCamel} — Throws on first error\n * - {@link isCamel} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validateCamel<T>(input: T): IValidation<CamelCase<T>>;\n\n/** @internal */\nexport function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;\n\n/** @internal */\nexport function validateCamel(): never {\n  return NoTransformConfigurationError(\"notations.validateCamel\");\n}\n\n/* -----------------------------------------------------------\n    PASCAL CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to PascalCase.\n *\n * Transforms all property names in the object (including nested) to PascalCase\n * convention. Creates a new object with renamed properties. Distinct source\n * keys that become the same destination key are rejected with an error instead\n * of silently discarding a value. This collision policy also applies to the\n * assert, is, validate, and factory variants.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertPascal} — Throws on type mismatch\n * - {@link isPascal} — Returns `null` on type mismatch\n * - {@link validatePascal} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with PascalCase property names\n * @throws {Error} When two source keys become the same destination key\n */\nexport function pascal<T>(input: T): PascalCase<T>;\n\n/** @internal */\nexport function pascal(): never {\n  return NoTransformConfigurationError(\"notations.pascal\");\n}\n\n/**\n * Converts property names to PascalCase with assertion.\n *\n * Transforms all property names to PascalCase with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link pascal} — No validation\n * - {@link isPascal} — Returns `null` instead of throwing\n * - {@link validatePascal} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with PascalCase property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertPascal<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): PascalCase<T>;\n\n/** @internal */\nexport function assertPascal<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): PascalCase<T>;\n\n/** @internal */\nexport function assertPascal(): never {\n  return NoTransformConfigurationError(\"notations.assertPascal\");\n}\n\n/**\n * Converts property names to PascalCase with type checking.\n *\n * Transforms all property names to PascalCase with {@link is} validation.\n * Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link pascal} — No validation\n * - {@link assertPascal} — Throws instead of returning `null`\n * - {@link validatePascal} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with PascalCase property names, or `null` if invalid\n */\nexport function isPascal<T>(input: T): PascalCase<T> | null;\n\n/** @internal */\nexport function isPascal<T>(input: unknown): PascalCase<T> | null;\n\n/** @internal */\nexport function isPascal(): never {\n  return NoTransformConfigurationError(\"notations.isPascal\");\n}\n\n/**\n * Converts property names to PascalCase with validation.\n *\n * Transforms all property names to PascalCase with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link pascal} — No validation\n * - {@link assertPascal} — Throws on first error\n * - {@link isPascal} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validatePascal<T>(input: T): IValidation<PascalCase<T>>;\n\n/** @internal */\nexport function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;\n\n/** @internal */\nexport function validatePascal(): never {\n  return NoTransformConfigurationError(\"notations.validatePascal\");\n}\n\n/* -----------------------------------------------------------\n    SNAKE CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to snake_case.\n *\n * Transforms all property names in the object (including nested) to snake_case\n * convention. Creates a new object with renamed properties. Distinct source\n * keys that become the same destination key are rejected with an error instead\n * of silently discarding a value. This collision policy also applies to the\n * assert, is, validate, and factory variants.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertSnake} — Throws on type mismatch\n * - {@link isSnake} — Returns `null` on type mismatch\n * - {@link validateSnake} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with snake_case property names\n * @throws {Error} When two source keys become the same destination key\n */\nexport function snake<T>(input: T): SnakeCase<T>;\n\n/** @internal */\nexport function snake(): never {\n  return NoTransformConfigurationError(\"notations.snake\");\n}\n\n/**\n * Converts property names to snake_case with assertion.\n *\n * Transforms all property names to snake_case with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link snake} — No validation\n * - {@link isSnake} — Returns `null` instead of throwing\n * - {@link validateSnake} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with snake_case property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertSnake<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): SnakeCase<T>;\n\n/** @internal */\nexport function assertSnake<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): SnakeCase<T>;\n\n/** @internal */\nexport function assertSnake(): never {\n  return NoTransformConfigurationError(\"notations.assertSnake\");\n}\n\n/**\n * Converts property names to snake_case with type checking.\n *\n * Transforms all property names to snake_case with {@link is} validation.\n * Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link snake} — No validation\n * - {@link assertSnake} — Throws instead of returning `null`\n * - {@link validateSnake} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with snake_case property names, or `null` if invalid\n */\nexport function isSnake<T>(input: T): SnakeCase<T> | null;\n\n/** @internal */\nexport function isSnake<T>(input: unknown): SnakeCase<T> | null;\n\n/** @internal */\nexport function isSnake(): never {\n  return NoTransformConfigurationError(\"notations.isSnake\");\n}\n\n/**\n * Converts property names to snake_case with validation.\n *\n * Transforms all property names to snake_case with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link snake} — No validation\n * - {@link assertSnake} — Throws on first error\n * - {@link isSnake} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;\n\n/** @internal */\nexport function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;\n\n/** @internal */\nexport function validateSnake(): never {\n  return NoTransformConfigurationError(\"notations.validateSnake\");\n}\n\n/* -----------------------------------------------------------\n    KEBAB CASE\n----------------------------------------------------------- */\n/**\n * Converts property names to kebab-case.\n *\n * Transforms all property names in the object (including nested) to kebab-case\n * convention. Creates a new object with renamed properties. Distinct source\n * keys that become the same destination key are rejected with an error instead\n * of silently discarding a value. This collision policy also applies to the\n * assert, is, validate, and factory variants.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertKebab} — Throws on type mismatch\n * - {@link isKebab} — Returns `null` on type mismatch\n * - {@link validateKebab} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with kebab-case property names\n * @throws {Error} When two source keys become the same destination key\n */\nexport function kebab<T>(input: T): KebabCase<T>;\n\n/** @internal */\nexport function kebab(): never {\n  return NoTransformConfigurationError(\"notations.kebab\");\n}\n\n/**\n * Converts property names to kebab-case with assertion.\n *\n * Transforms all property names to kebab-case with {@link assert} validation.\n * Throws {@link TypeGuardError} on type mismatch.\n *\n * Related functions:\n *\n * - {@link kebab} — No validation\n * - {@link isKebab} — Returns `null` instead of throwing\n * - {@link validateKebab} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns New object with kebab-case property names\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertKebab<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): KebabCase<T>;\n\n/** @internal */\nexport function assertKebab<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): KebabCase<T>;\n\n/** @internal */\nexport function assertKebab(): never {\n  return NoTransformConfigurationError(\"notations.assertKebab\");\n}\n\n/**\n * Converts property names to kebab-case with type checking.\n *\n * Transforms all property names to kebab-case with {@link is} validation.\n * Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link kebab} — No validation\n * - {@link assertKebab} — Throws instead of returning `null`\n * - {@link validateKebab} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns New object with kebab-case property names, or `null` if invalid\n */\nexport function isKebab<T>(input: T): KebabCase<T> | null;\n\n/** @internal */\nexport function isKebab<T>(input: unknown): KebabCase<T> | null;\n\n/** @internal */\nexport function isKebab(): never {\n  return NoTransformConfigurationError(\"notations.isKebab\");\n}\n\n/**\n * Converts property names to kebab-case with validation.\n *\n * Transforms all property names to kebab-case with {@link validate} validation.\n * Returns {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with converted object.\n *\n * Related functions:\n *\n * - {@link kebab} — No validation\n * - {@link assertKebab} — Throws on first error\n * - {@link isKebab} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Object to convert\n * @returns Validation result containing converted object or errors\n */\nexport function validateKebab<T>(input: T): IValidation<KebabCase<T>>;\n\n/** @internal */\nexport function validateKebab<T>(input: unknown): IValidation<KebabCase<T>>;\n\n/** @internal */\nexport function validateKebab(): never {\n  return NoTransformConfigurationError(\"notations.validateKebab\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link camel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createCamel(): never;\n\n/**\n * Creates reusable {@link camel} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createCamel<T>(): (input: T) => CamelCase<T>;\n\n/** @internal */\nexport function createCamel(): never {\n  NoTransformConfigurationError(\"notations.createCamel\");\n}\n\n/**\n * Creates reusable {@link assertCamel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertCamel(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertCamel} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertCamel<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => CamelCase<T>;\n\n/** @internal */\nexport function createAssertCamel(): never {\n  NoTransformConfigurationError(\"notations.createAssertCamel\");\n}\n\n/**\n * Creates reusable {@link isCamel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsCamel(): never;\n\n/**\n * Creates reusable {@link isCamel} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsCamel<T>(): (input: T) => CamelCase<T> | null;\n\n/** @internal */\nexport function createIsCamel(): never {\n  NoTransformConfigurationError(\"notations.createIsCamel\");\n}\n\n/**\n * Creates reusable {@link validateCamel} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateCamel(): never;\n\n/**\n * Creates reusable {@link validateCamel} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidateCamel<T>(): (\n  input: T,\n) => IValidation<CamelCase<T>>;\n\n/** @internal */\nexport function createValidateCamel(): never {\n  NoTransformConfigurationError(\"notations.createValidateCamel\");\n}\n\n/**\n * Creates reusable {@link pascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createPascal(): never;\n\n/**\n * Creates reusable {@link pascal} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createPascal<T>(): (input: T) => PascalCase<T>;\n\n/** @internal */\nexport function createPascal(): never {\n  NoTransformConfigurationError(\"notations.createPascal\");\n}\n\n/**\n * Creates reusable {@link assertPascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertPascal(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertPascal} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertPascal<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => PascalCase<T>;\n\n/** @internal */\nexport function createAssertPascal(): never {\n  NoTransformConfigurationError(\"notations.createAssertPascal\");\n}\n\n/**\n * Creates reusable {@link isPascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsPascal(): never;\n\n/**\n * Creates reusable {@link isPascal} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsPascal<T>(): (input: T) => PascalCase<T> | null;\n\n/** @internal */\nexport function createIsPascal(): never {\n  NoTransformConfigurationError(\"notations.createIsPascal\");\n}\n\n/**\n * Creates reusable {@link validatePascal} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidatePascal(): never;\n\n/**\n * Creates reusable {@link validatePascal} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidatePascal<T>(): (\n  input: T,\n) => IValidation<PascalCase<T>>;\n\n/** @internal */\nexport function createValidatePascal(): never {\n  NoTransformConfigurationError(\"notations.createValidatePascal\");\n}\n\n/**\n * Creates reusable {@link snake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createSnake(): never;\n\n/**\n * Creates reusable {@link snake} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createSnake<T>(): (input: T) => SnakeCase<T>;\n\n/** @internal */\nexport function createSnake(): never {\n  NoTransformConfigurationError(\"notations.createSnake\");\n}\n\n/**\n * Creates reusable {@link assertSnake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertSnake(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertSnake} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertSnake<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => SnakeCase<T>;\n\n/** @internal */\nexport function createAssertSnake(): never {\n  NoTransformConfigurationError(\"notations.createAssertSnake\");\n}\n\n/**\n * Creates reusable {@link isSnake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsSnake(): never;\n\n/**\n * Creates reusable {@link isSnake} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;\n\n/** @internal */\nexport function createIsSnake(): never {\n  NoTransformConfigurationError(\"notations.createIsSnake\");\n}\n\n/**\n * Creates reusable {@link validateSnake} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateSnake(): never;\n\n/**\n * Creates reusable {@link validateSnake} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidateSnake<T>(): (\n  input: T,\n) => IValidation<SnakeCase<T>>;\n\n/** @internal */\nexport function createValidateSnake(): never {\n  NoTransformConfigurationError(\"notations.createValidateSnake\");\n}\n\n/**\n * Creates reusable {@link kebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createKebab(): never;\n\n/**\n * Creates reusable {@link kebab} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createKebab<T>(): (input: T) => KebabCase<T>;\n\n/** @internal */\nexport function createKebab(): never {\n  NoTransformConfigurationError(\"notations.createKebab\");\n}\n\n/**\n * Creates reusable {@link assertKebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertKebab(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertKebab} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable conversion function\n */\nexport function createAssertKebab<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: T) => KebabCase<T>;\n\n/** @internal */\nexport function createAssertKebab(): never {\n  NoTransformConfigurationError(\"notations.createAssertKebab\");\n}\n\n/**\n * Creates reusable {@link isKebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsKebab(): never;\n\n/**\n * Creates reusable {@link isKebab} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createIsKebab<T>(): (input: T) => KebabCase<T> | null;\n\n/** @internal */\nexport function createIsKebab(): never {\n  NoTransformConfigurationError(\"notations.createIsKebab\");\n}\n\n/**\n * Creates reusable {@link validateKebab} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateKebab(): never;\n\n/**\n * Creates reusable {@link validateKebab} function.\n *\n * @template T Type of input value\n * @returns Reusable conversion function\n */\nexport function createValidateKebab<T>(): (\n  input: T,\n) => IValidation<KebabCase<T>>;\n\n/** @internal */\nexport function createValidateKebab(): never {\n  NoTransformConfigurationError(\"notations.createValidateKebab\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,QAAe;CAC7B,OAAO,8BAA8B,iBAAiB;AACxD;;AAiCA,SAAgB,cAAqB;CACnC,OAAO,8BAA8B,uBAAuB;AAC9D;;AAwBA,SAAgB,UAAiB;CAC/B,OAAO,8BAA8B,mBAAmB;AAC1D;;AAyBA,SAAgB,gBAAuB;CACrC,OAAO,8BAA8B,yBAAyB;AAChE;;AA4BA,SAAgB,SAAgB;CAC9B,OAAO,8BAA8B,kBAAkB;AACzD;;AAiCA,SAAgB,eAAsB;CACpC,OAAO,8BAA8B,wBAAwB;AAC/D;;AAwBA,SAAgB,WAAkB;CAChC,OAAO,8BAA8B,oBAAoB;AAC3D;;AAyBA,SAAgB,iBAAwB;CACtC,OAAO,8BAA8B,0BAA0B;AACjE;;AA4BA,SAAgB,QAAe;CAC7B,OAAO,8BAA8B,iBAAiB;AACxD;;AAiCA,SAAgB,cAAqB;CACnC,OAAO,8BAA8B,uBAAuB;AAC9D;;AAwBA,SAAgB,UAAiB;CAC/B,OAAO,8BAA8B,mBAAmB;AAC1D;;AAyBA,SAAgB,gBAAuB;CACrC,OAAO,8BAA8B,yBAAyB;AAChE;;AA4BA,SAAgB,QAAe;CAC7B,OAAO,8BAA8B,iBAAiB;AACxD;;AAiCA,SAAgB,cAAqB;CACnC,OAAO,8BAA8B,uBAAuB;AAC9D;;AAwBA,SAAgB,UAAiB;CAC/B,OAAO,8BAA8B,mBAAmB;AAC1D;;AAyBA,SAAgB,gBAAuB;CACrC,OAAO,8BAA8B,yBAAyB;AAChE;;AAqBA,SAAgB,cAAqB;CACnC,8BAA8B,uBAAuB;AACvD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,6BAA6B;AAC7D;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,+BAA+B;AAC/D;;AAkBA,SAAgB,eAAsB;CACpC,8BAA8B,wBAAwB;AACxD;;AAwBA,SAAgB,qBAA4B;CAC1C,8BAA8B,8BAA8B;AAC9D;;AAkBA,SAAgB,iBAAwB;CACtC,8BAA8B,0BAA0B;AAC1D;;AAoBA,SAAgB,uBAA8B;CAC5C,8BAA8B,gCAAgC;AAChE;;AAkBA,SAAgB,cAAqB;CACnC,8BAA8B,uBAAuB;AACvD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,6BAA6B;AAC7D;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,+BAA+B;AAC/D;;AAkBA,SAAgB,cAAqB;CACnC,8BAA8B,uBAAuB;AACvD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,6BAA6B;AAC7D;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,+BAA+B;AAC/D"}