typia 13.0.0 → 13.0.1

package/lib/json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"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"}

package/lib/llm.mjs

@@ -1,3 +1,54 @@
-export { application, coerce, controller, createCoerce, createParse, parameters, parse, schema, structuredOutput } from './llm2.mjs';
-export { __exports as default } from './_virtual/llm.mjs';
-//# sourceMappingURL=llm.mjs.map
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/llm.ts
+var llm_exports = /* @__PURE__ */ __exportAll({
+	application: () => application,
+	coerce: () => coerce,
+	controller: () => controller,
+	createCoerce: () => createCoerce,
+	createParse: () => createParse,
+	parameters: () => parameters,
+	parse: () => parse,
+	schema: () => schema,
+	structuredOutput: () => structuredOutput
+});
+/** @internal */
+function controller(..._args) {
+	NoTransformConfigurationError("llm.controller");
+}
+/** @internal */
+function application() {
+	NoTransformConfigurationError("llm.application");
+}
+/** @internal */
+function structuredOutput() {
+	NoTransformConfigurationError("llm.structuredOutput");
+}
+/** @internal */
+function parameters() {
+	NoTransformConfigurationError("llm.parameters");
+}
+/** @internal */
+function schema() {
+	NoTransformConfigurationError("llm.schema");
+}
+/** @internal */
+function parse() {
+	NoTransformConfigurationError("llm.parse");
+}
+/** @internal */
+function coerce() {
+	NoTransformConfigurationError("llm.coerce");
+}
+/** @internal */
+function createParse() {
+	NoTransformConfigurationError("llm.createParse");
+}
+/** @internal */
+function createCoerce() {
+	NoTransformConfigurationError("llm.createCoerce");
+}
+//#endregion
+export { application, coerce, controller, createCoerce, createParse, llm_exports, parameters, parse, schema, structuredOutput };
+
+//# sourceMappingURL=llm.mjs.map

package/lib/llm.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"llm.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"llm.mjs","names":[],"sources":["../src/llm.ts"],"sourcesContent":["import {\n  IJsonParseResult,\n  ILlmApplication,\n  ILlmController,\n  ILlmSchema,\n  ILlmStructuredOutput,\n} from \"@typia/interface\";\n\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* -----------------------------------------------------------\n  FUNCTION CALLING\n----------------------------------------------------------- */\n/**\n * Creates LLM function calling controller.\n *\n * @danger You must configure the generic argument `Class`\n */\nexport function controller(\n  name: string,\n  execute: object,\n  config?: Partial<Pick<ILlmApplication.IConfig<any>, \"validate\">>,\n): never;\n\n/**\n * Creates LLM function calling controller from class/interface.\n *\n * Generates {@link ILlmController} from a TypeScript class or interface,\n * containing both function calling schemas ({@link ILlmFunction}) and an\n * executor ({@link ILlmController.execute}).\n *\n * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}\n * function that validates LLM-generated arguments before execution. When\n * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format\n * errors for LLM feedback, enabling auto-correction.\n *\n * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM\n * automatically selects functions and fills arguments from conversation.\n * Execute the selected function via {@link ILlmController.execute}.\n *\n * Related functions:\n *\n * - {@link application} — Schemas only, without executor\n * - {@link parameters} — Single parameters schema for structured output\n * - {@link schema} — Single type schema\n *\n * @template Class Target class or interface type\n * @template Config LLM schema configuration\n * @param name Controller identifier name\n * @param execute Executor instance\n * @param config LLM application options\n * @returns LLM function calling controller\n */\nexport function controller<\n  Class extends Record<string, any>,\n  Config extends Partial<\n    ILlmSchema.IConfig & {\n      /**\n       * Whether to disallow superfluous properties or not.\n       *\n       * If configure as `true`, {@link validateEquals} function would be used\n       * for validation feedback, which is more strict than {@link validate}\n       * function.\n       *\n       * @default false\n       */\n      equals: boolean;\n    }\n  > = {},\n>(\n  name: string,\n  execute: Class,\n  config?: Partial<Pick<ILlmApplication.IConfig<Class>, \"validate\">>,\n): ILlmController<Class>;\n\n/** @internal */\nexport function controller(..._args: any[]): never {\n  NoTransformConfigurationError(\"llm.controller\");\n}\n\n/**\n * Creates LLM function calling application.\n *\n * @danger You must configure the generic argument `Class`\n */\nexport function application(\n  config?: Partial<Pick<ILlmApplication.IConfig<any>, \"validate\">>,\n): never;\n\n/**\n * Creates LLM function calling application from class/interface.\n *\n * Generates {@link ILlmApplication} from a TypeScript class or interface,\n * containing function calling schemas ({@link ILlmFunction}). Does not include\n * an executor—use {@link controller} if you need execution capability.\n *\n * Each {@link ILlmFunction} includes a built-in {@link ILlmFunction.validate}\n * function that validates LLM-generated arguments before execution. When\n * validation fails, use `LlmJson.stringify()` from `@typia/utils` to format\n * errors for LLM feedback, enabling auto-correction.\n *\n * When passed to LLM providers (ChatGPT, Claude, Gemini, etc.), the LLM\n * automatically selects functions and fills arguments from conversation. You\n * execute the function manually with the LLM-prepared arguments.\n *\n * Related functions:\n *\n * - {@link controller} — Includes executor alongside schemas\n * - {@link parameters} — Single parameters schema for structured output\n * - {@link schema} — Single type schema\n *\n * @template Class Target class or interface type\n * @template Config LLM schema configuration\n * @param config LLM application options\n * @returns LLM function calling application\n */\nexport function application<\n  Class extends Record<string, any>,\n  Config extends Partial<\n    ILlmSchema.IConfig & {\n      /**\n       * Whether to disallow superfluous properties or not.\n       *\n       * If configure as `true`, {@link validateEquals} function would be used\n       * for validation feedback, which is more strict than {@link validate}\n       * function.\n       *\n       * @default false\n       */\n      equals: boolean;\n    }\n  > = {},\n>(\n  config?: Partial<Pick<ILlmApplication.IConfig<Class>, \"validate\">>,\n): ILlmApplication<Class>;\n\n/** @internal */\nexport function application(): never {\n  NoTransformConfigurationError(\"llm.application\");\n}\n\n/**\n * Creates LLM structured output interface.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function structuredOutput(): never;\n\n/**\n * Creates LLM structured output interface from TypeScript object type.\n *\n * Generates {@link ILlmStructuredOutput} containing everything needed for\n * handling LLM structured outputs: the JSON schema for prompting, and functions\n * for parsing, coercing, and validating responses.\n *\n * Structured outputs allow LLMs to generate data conforming to a predefined\n * schema instead of free-form text. This is useful for:\n *\n * - Extracting structured data from conversations\n * - Generating typed responses for downstream processing\n * - Ensuring consistent output formats across LLM calls\n *\n * Workflow:\n *\n * 1. Pass {@link ILlmStructuredOutput.parameters} schema to LLM provider\n * 2. Receive LLM response (JSON string or pre-parsed object)\n * 3. Use {@link ILlmStructuredOutput.parse} for raw strings or\n *    {@link ILlmStructuredOutput.coerce} for pre-parsed objects\n * 4. Use {@link ILlmStructuredOutput.validate} to check the result\n *\n * Related functions:\n *\n * - {@link parameters} — Schema only, without parse/coerce/validate\n * - {@link application} — Multiple function schemas from class/interface\n * - {@link controller} — Application with executor\n *\n * @template T Target output type (object with static properties)\n * @template Config LLM schema configuration\n * @returns LLM structured output interface\n */\nexport function structuredOutput<\n  T extends Record<string, any>,\n  Config extends Partial<\n    ILlmSchema.IConfig & {\n      /**\n       * Whether to disallow superfluous properties or not.\n       *\n       * If configure as `true`, {@link validateEquals} function would be used\n       * for validation feedback, which is more strict than {@link validate}\n       * function.\n       *\n       * @default false\n       */\n      equals: boolean;\n    }\n  > = {},\n>(): ILlmStructuredOutput<T>;\n\n/** @internal */\nexport function structuredOutput(): never {\n  NoTransformConfigurationError(\"llm.structuredOutput\");\n}\n\n/* -----------------------------------------------------------\n  RAW SCHEMAS\n----------------------------------------------------------- */\n/**\n * Creates LLM parameters schema.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function parameters(): never;\n\n/**\n * Creates LLM parameters schema from TypeScript object type.\n *\n * Generates {@link ILlmSchema.IParameters} for LLM function calling or\n * structured outputs. LLMs use keyworded arguments only, so the type must be an\n * object with static properties (no dynamic properties allowed).\n *\n * Use cases:\n *\n * - Function calling: LLM fills parameters from conversation\n * - Structured outputs: LLM generates structured data, not plain text\n *\n * Related functions:\n *\n * - {@link application} — Multiple function schemas from class/interface\n * - {@link controller} — Application with executor\n * - {@link schema} — Single type schema (not parameters-specific)\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @returns LLM parameters schema\n */\nexport function parameters<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(): ILlmSchema.IParameters;\n\n/** @internal */\nexport function parameters(): never {\n  NoTransformConfigurationError(\"llm.parameters\");\n}\n\n/**\n * Creates LLM type schema.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function schema(): never;\n\n/**\n * Creates LLM type schema from TypeScript type.\n *\n * Generates {@link ILlmSchema} for use in LLM function calling. For actual\n * function calling with TypeScript functions, use {@link application}. For\n * structured output generation, use {@link parameters}.\n *\n * LLM function calling flow:\n *\n * 1. LLM selects function and fills arguments from conversation\n * 2. You execute the function with LLM-prepared arguments\n * 3. Return value is passed back to LLM via system prompt\n * 4. LLM continues conversation based on return value\n *\n * Related functions:\n *\n * - {@link application} — Multiple function schemas from class/interface\n * - {@link controller} — Application with executor\n * - {@link parameters} — Parameters schema for structured output\n *\n * @template T Target type\n * @template Config LLM schema configuration\n * @param $defs Shared schema definitions for `$ref` referencing\n * @returns LLM type schema\n */\nexport function schema<T, Config = {}>(\n  $defs: Record<string, ILlmSchema>,\n): ILlmSchema;\n\n/** @internal */\nexport function schema(): never {\n  NoTransformConfigurationError(\"llm.schema\");\n}\n\n/* -----------------------------------------------------------\n  UTILITY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Parse LLM response JSON with type coercion.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function parse(input: string): never;\n\n/**\n * Parse lenient JSON with schema-based type coercion.\n *\n * Handles incomplete or malformed JSON commonly produced by LLMs:\n *\n * - Unclosed brackets, strings, trailing commas\n * - JavaScript-style comments (`//` and multi-line)\n * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)\n * - Markdown code block extraction, junk prefix skipping\n *\n * Also coerces double-stringified values based on the `Parameters` schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * For repeated parsing, use {@link createParse} to avoid regenerating the schema\n * each time.\n *\n * Related functions:\n *\n * - {@link createParse} — Create reusable parser function\n * - {@link coerce} — Type coercion for already-parsed objects\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @param input Raw JSON string (potentially incomplete or malformed)\n * @returns Parse result with typed data on success, or partial data with errors\n */\nexport function parse<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(input: string): IJsonParseResult<Parameters>;\n\n/** @internal */\nexport function parse(): never {\n  NoTransformConfigurationError(\"llm.parse\");\n}\n\n/**\n * Coerce LLM arguments to match expected schema types.\n *\n * LLMs often return values with incorrect types (e.g., numbers as strings).\n * This function recursively coerces values based on the `Parameters` schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Use this when your SDK provides already-parsed objects but values may have\n * wrong types. For raw JSON strings, use {@link parse} instead.\n *\n * For repeated coercion, use {@link createCoerce} to avoid regenerating the\n * schema each time.\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * Related functions:\n *\n * - {@link createCoerce} — Create reusable coercer function\n * - {@link parse} — Parse and coerce raw JSON strings\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @param input Parsed arguments object from LLM (with potentially wrong types)\n * @returns Coerced arguments with corrected types\n */\nexport function coerce<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(input: Parameters): Parameters;\n\n/** @internal */\nexport function coerce(): never {\n  NoTransformConfigurationError(\"llm.coerce\");\n}\n\n/**\n * Create reusable LLM JSON parser with type coercion.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function createParse(): never;\n\n/**\n * Create reusable lenient JSON parser with schema-based type coercion.\n *\n * Returns a parser function that handles incomplete or malformed JSON commonly\n * produced by LLMs:\n *\n * - Unclosed brackets, strings, trailing commas\n * - JavaScript-style comments (`//` and multi-line)\n * - Unquoted object keys, incomplete keywords (`tru`, `fal`, `nul`)\n * - Markdown code block extraction, junk prefix skipping\n *\n * Also coerces double-stringified values based on the `Parameters` schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Use this instead of {@link parse} when parsing multiple inputs to avoid\n * regenerating the schema each time.\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * Related functions:\n *\n * - {@link parse} — One-shot parsing (regenerates schema each call)\n * - {@link createCoerce} — Create reusable coercer function\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @returns Reusable parser function\n */\nexport function createParse<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(): (input: string) => IJsonParseResult<Parameters>;\n\n/** @internal */\nexport function createParse(): never {\n  NoTransformConfigurationError(\"llm.createParse\");\n}\n\n/**\n * Create reusable LLM arguments coercer.\n *\n * @danger You must configure the generic argument `Parameters`\n */\nexport function createCoerce(): never;\n\n/**\n * Create reusable coercer for LLM arguments.\n *\n * Returns a coercer function that fixes incorrect types commonly returned by\n * LLMs (e.g., numbers as strings). Coerces values based on the `Parameters`\n * schema:\n *\n * - `\"42\"` → `42` (when schema expects number)\n * - `\"true\"` → `true` (when schema expects boolean)\n * - `\"null\"` → `null` (when schema expects null)\n * - `\"{...}\"` → `{...}` (when schema expects object)\n * - `\"[...]\"` → `[...]` (when schema expects array)\n *\n * Use this instead of {@link coerce} when coercing multiple inputs to avoid\n * regenerating the schema each time.\n *\n * Type validation is NOT performed—use {@link ILlmFunction.validate} or\n * `typia.validate()` for that.\n *\n * Related functions:\n *\n * - {@link coerce} — One-shot coercion (regenerates schema each call)\n * - {@link createParse} — Create reusable parser function\n * - {@link parameters} — Generate parameters schema from type\n *\n * @template Parameters Target parameters type (object with static properties)\n * @template Config LLM schema configuration\n * @returns Reusable coercer function\n */\nexport function createCoerce<\n  Parameters extends Record<string, any>,\n  Config extends Partial<ILlmSchema.IConfig> = {},\n>(): (input: Parameters) => Parameters;\n\n/** @internal */\nexport function createCoerce(): never {\n  NoTransformConfigurationError(\"llm.createCoerce\");\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4EA,SAAgB,WAAW,GAAG,OAAqB;CACjD,8BAA8B,gBAAgB;AAChD;;AA2DA,SAAgB,cAAqB;CACnC,8BAA8B,iBAAiB;AACjD;;AA4DA,SAAgB,mBAA0B;CACxC,8BAA8B,sBAAsB;AACtD;;AAwCA,SAAgB,aAAoB;CAClC,8BAA8B,gBAAgB;AAChD;;AAuCA,SAAgB,SAAgB;CAC9B,8BAA8B,YAAY;AAC5C;;AAqDA,SAAgB,QAAe;CAC7B,8BAA8B,WAAW;AAC3C;;AAwCA,SAAgB,SAAgB;CAC9B,8BAA8B,YAAY;AAC5C;;AAkDA,SAAgB,cAAqB;CACnC,8BAA8B,iBAAiB;AACjD;;AA4CA,SAAgB,eAAsB;CACpC,8BAA8B,kBAAkB;AAClD"}

package/lib/module.mjs

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

package/lib/module.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"module.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"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"}

package/lib/notations.mjs

@@ -1,3 +1,169 @@
-export { assertCamel, assertKebab, assertPascal, assertSnake, camel, createAssertCamel, createAssertKebab, createAssertPascal, createAssertSnake, createCamel, createIsCamel, createIsKebab, createIsPascal, createIsSnake, createKebab, createPascal, createSnake, createValidateCamel, createValidateKebab, createValidatePascal, createValidateSnake, isCamel, isKebab, isPascal, isSnake, kebab, pascal, snake, validateCamel, validateKebab, validatePascal, validateSnake } from './notations2.mjs';
-export { __exports as default } from './_virtual/notations.mjs';
-//# sourceMappingURL=notations.mjs.map
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/notations.ts
+var notations_exports = /* @__PURE__ */ __exportAll({
+	assertCamel: () => assertCamel,
+	assertKebab: () => assertKebab,
+	assertPascal: () => assertPascal,
+	assertSnake: () => assertSnake,
+	camel: () => camel,
+	createAssertCamel: () => createAssertCamel,
+	createAssertKebab: () => createAssertKebab,
+	createAssertPascal: () => createAssertPascal,
+	createAssertSnake: () => createAssertSnake,
+	createCamel: () => createCamel,
+	createIsCamel: () => createIsCamel,
+	createIsKebab: () => createIsKebab,
+	createIsPascal: () => createIsPascal,
+	createIsSnake: () => createIsSnake,
+	createKebab: () => createKebab,
+	createPascal: () => createPascal,
+	createSnake: () => createSnake,
+	createValidateCamel: () => createValidateCamel,
+	createValidateKebab: () => createValidateKebab,
+	createValidatePascal: () => createValidatePascal,
+	createValidateSnake: () => createValidateSnake,
+	isCamel: () => isCamel,
+	isKebab: () => isKebab,
+	isPascal: () => isPascal,
+	isSnake: () => isSnake,
+	kebab: () => kebab,
+	pascal: () => pascal,
+	snake: () => snake,
+	validateCamel: () => validateCamel,
+	validateKebab: () => validateKebab,
+	validatePascal: () => validatePascal,
+	validateSnake: () => validateSnake
+});
+/** @internal */
+function camel() {
+	return NoTransformConfigurationError("notations.camel");
+}
+/** @internal */
+function assertCamel() {
+	return NoTransformConfigurationError("notations.assertCamel");
+}
+/** @internal */
+function isCamel() {
+	return NoTransformConfigurationError("notations.isCamel");
+}
+/** @internal */
+function validateCamel() {
+	return NoTransformConfigurationError("notations.validateCamel");
+}
+/** @internal */
+function pascal() {
+	return NoTransformConfigurationError("notations.pascal");
+}
+/** @internal */
+function assertPascal() {
+	return NoTransformConfigurationError("notations.assertPascal");
+}
+/** @internal */
+function isPascal() {
+	return NoTransformConfigurationError("notations.isPascal");
+}
+/** @internal */
+function validatePascal() {
+	return NoTransformConfigurationError("notations.validatePascal");
+}
+/** @internal */
+function snake() {
+	return NoTransformConfigurationError("notations.snake");
+}
+/** @internal */
+function assertSnake() {
+	return NoTransformConfigurationError("notations.assertSnake");
+}
+/** @internal */
+function isSnake() {
+	return NoTransformConfigurationError("notations.isSnake");
+}
+/** @internal */
+function validateSnake() {
+	return NoTransformConfigurationError("notations.validateSnake");
+}
+/** @internal */
+function kebab() {
+	return NoTransformConfigurationError("notations.kebab");
+}
+/** @internal */
+function assertKebab() {
+	return NoTransformConfigurationError("notations.assertKebab");
+}
+/** @internal */
+function isKebab() {
+	return NoTransformConfigurationError("notations.isKebab");
+}
+/** @internal */
+function validateKebab() {
+	return NoTransformConfigurationError("notations.validateKebab");
+}
+/** @internal */
+function createCamel() {
+	NoTransformConfigurationError("notations.createCamel");
+}
+/** @internal */
+function createAssertCamel() {
+	NoTransformConfigurationError("notations.createAssertCamel");
+}
+/** @internal */
+function createIsCamel() {
+	NoTransformConfigurationError("notations.createIsCamel");
+}
+/** @internal */
+function createValidateCamel() {
+	NoTransformConfigurationError("notations.createValidateCamel");
+}
+/** @internal */
+function createPascal() {
+	NoTransformConfigurationError("notations.createPascal");
+}
+/** @internal */
+function createAssertPascal() {
+	NoTransformConfigurationError("notations.createAssertPascal");
+}
+/** @internal */
+function createIsPascal() {
+	NoTransformConfigurationError("notations.createIsPascal");
+}
+/** @internal */
+function createValidatePascal() {
+	NoTransformConfigurationError("notations.createValidatePascal");
+}
+/** @internal */
+function createSnake() {
+	NoTransformConfigurationError("notations.createSnake");
+}
+/** @internal */
+function createAssertSnake() {
+	NoTransformConfigurationError("notations.createAssertSnake");
+}
+/** @internal */
+function createIsSnake() {
+	NoTransformConfigurationError("notations.createIsSnake");
+}
+/** @internal */
+function createValidateSnake() {
+	NoTransformConfigurationError("notations.createValidateSnake");
+}
+/** @internal */
+function createKebab() {
+	NoTransformConfigurationError("notations.createKebab");
+}
+/** @internal */
+function createAssertKebab() {
+	NoTransformConfigurationError("notations.createAssertKebab");
+}
+/** @internal */
+function createIsKebab() {
+	NoTransformConfigurationError("notations.createIsKebab");
+}
+/** @internal */
+function createValidateKebab() {
+	NoTransformConfigurationError("notations.createValidateKebab");
+}
+//#endregion
+export { assertCamel, assertKebab, assertPascal, assertSnake, camel, createAssertCamel, createAssertKebab, createAssertPascal, createAssertSnake, createCamel, createIsCamel, createIsKebab, createIsPascal, createIsSnake, createKebab, createPascal, createSnake, createValidateCamel, createValidateKebab, createValidatePascal, createValidateSnake, isCamel, isKebab, isPascal, isSnake, kebab, notations_exports, pascal, snake, validateCamel, validateKebab, validatePascal, validateSnake };
+
+//# sourceMappingURL=notations.mjs.map

package/lib/notations.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"notations.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"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"}