typia 15.0.0 → 15.1.0

package/lib/protobuf.js.map

@@ -1 +1 @@
-{"version":3,"file":"protobuf.js","sourceRoot":"","sources":["../src/protobuf.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAGA,gGAA6F;AAiC7F,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AACpD,CAAC;AAkCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AAwCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AA8BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AACrD,CAAC;AAgCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AA0BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AAoCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AA0BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AACrD,CAAC;AA4BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAoBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AA0BD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAmBD,gBAAgB;AAChB;IAGE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAiBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AA0BD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAmBD,gBAAgB;AAChB;IAGE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC"}
+{"version":3,"file":"protobuf.js","sourceRoot":"","sources":["../src/protobuf.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAGA,gGAA6F;AAmC7F,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AACpD,CAAC;AAoCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AA2CD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAgCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AACrD,CAAC;AAkCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AA6BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AAwCD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AA6BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,mBAAmB,CAAC,CAAC;AACrD,CAAC;AA+BD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AAqBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAkBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AA4BD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAoBD,gBAAgB;AAChB;IAGE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC;AAkBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,uBAAuB,CAAC,CAAC;AACzD,CAAC;AAkBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,yBAAyB,CAAC,CAAC;AAC3D,CAAC;AA4BD,gBAAgB;AAChB;IAIE,IAAA,6DAA6B,EAAC,6BAA6B,CAAC,CAAC;AAC/D,CAAC;AAoBD,gBAAgB;AAChB;IAGE,IAAA,6DAA6B,EAAC,+BAA+B,CAAC,CAAC;AACjE,CAAC"}

package/lib/protobuf.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"protobuf.mjs","names":[],"sources":["../src/protobuf.ts"],"sourcesContent":["import { IValidation, Resolved } from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* ===========================================================\n    PROTOCOL BUFFER\n      - MESSAGE\n      - DECODE\n      - ENCODE\n      - FACTORY FUNCTIONS\n==============================================================\n    SCHEMA\n----------------------------------------------------------- */\n/**\n * Generates Protocol Buffer message schema.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function message(): never;\n\n/**\n * Generates Protocol Buffer message schema for type `T`.\n *\n * Creates a `.proto` message definition string from a TypeScript type. Use for\n * sharing schemas with other languages/frameworks.\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Target type\n * @returns Protocol Buffer message schema string\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function message<T>(): string;\n\n/** @internal */\nexport function message(): never {\n  NoTransformConfigurationError(\"protobuf.message\");\n}\n\n/* -----------------------------------------------------------\n    DECODE\n----------------------------------------------------------- */\n/**\n * Decodes Protocol Buffer binary.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function decode(input: Uint8Array): never;\n\n/**\n * Decodes Protocol Buffer binary to type `T`.\n *\n * Converts Protocol Buffer binary data to a TypeScript instance. Binary data\n * must have been encoded from a `T`-typed value—invalid data causes undefined\n * behavior or errors.\n *\n * For type safety, ensure data was encoded via:\n *\n * - {@link assertEncode} — Encodes with type assertion\n * - {@link isEncode} — Encodes with type checking\n * - {@link validateEncode} — Encodes with validation\n *\n * Note: Decoder validation ({@link assertDecode}, etc.) only checks custom tags\n * like `number & Minimum<7>`, not structural type safety.\n *\n * @template T Target type\n * @param input Protocol Buffer binary data\n * @returns Decoded value of type `T`\n */\nexport function decode<T>(input: Uint8Array): Resolved<T>;\n\n/** @internal */\nexport function decode(): never {\n  NoTransformConfigurationError(\"protobuf.decode\");\n}\n\n/**\n * Decodes Protocol Buffer binary with assertion.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function assertDecode(\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Decodes Protocol Buffer binary with assertion (partial safety).\n *\n * Combines {@link decode} with {@link assert}. Throws {@link TypeGuardError} on\n * validation failure.\n *\n * Warning: Only validates custom tags (e.g., `number & Minimum<7>`, `string &\n * Format<\"uuid\">`), not structural type correctness. Ensure source data was\n * encoded with type-safe encoders.\n *\n * Related functions:\n *\n * - {@link decode} — No validation\n * - {@link isDecode} — Returns `null` instead of throwing\n * - {@link validateDecode} — Returns detailed validation errors\n *\n * @template T Target type\n * @param input Protocol Buffer binary data\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Decoded value of type `T`\n * @throws {TypeGuardError} When custom tag validation fails\n */\nexport function assertDecode<T>(\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Resolved<T>;\n\n/** @internal */\nexport function assertDecode(): never {\n  NoTransformConfigurationError(\"protobuf.assertDecode\");\n}\n\n/**\n * Decodes Protocol Buffer binary with type checking.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function isDecode(input: Uint8Array): never;\n\n/**\n * Decodes Protocol Buffer binary with type checking (partial safety).\n *\n * Combines {@link decode} with {@link is}. Returns `null` on validation failure.\n *\n * Warning: Only validates custom tags (e.g., `number & Minimum<7>`, `string &\n * Format<\"uuid\">`), not structural type correctness. Ensure source data was\n * encoded with type-safe encoders.\n *\n * Related functions:\n *\n * - {@link decode} — No validation\n * - {@link assertDecode} — Throws instead of returning `null`\n * - {@link validateDecode} — Returns detailed validation errors\n *\n * @template T Target type\n * @param input Protocol Buffer binary data\n * @returns Decoded value of type `T`, or `null` if invalid\n */\nexport function isDecode<T>(input: Uint8Array): Resolved<T> | null;\n\n/** @internal */\nexport function isDecode(): never {\n  NoTransformConfigurationError(\"protobuf.isDecode\");\n}\n\n/**\n * Decodes Protocol Buffer binary with validation.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function validateDecode(input: Uint8Array): never;\n\n/**\n * Decodes Protocol Buffer binary with validation (partial safety).\n *\n * Combines {@link decode} with {@link validate}. Returns\n * {@link IValidation.IFailure} with errors on mismatch, or\n * {@link IValidation.ISuccess} with decoded value.\n *\n * Warning: Only validates custom tags (e.g., `number & Minimum<7>`, `string &\n * Format<\"uuid\">`), not structural type correctness. Ensure source data was\n * encoded with type-safe encoders.\n *\n * Related functions:\n *\n * - {@link decode} — No validation\n * - {@link assertDecode} — Throws on first error\n * - {@link isDecode} — Returns `null` instead of error details\n *\n * @template T Target type\n * @param input Protocol Buffer binary data\n * @returns Validation result containing decoded value or errors\n */\nexport function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;\n\n/** @internal */\nexport function validateDecode(): never {\n  NoTransformConfigurationError(\"protobuf.validateDecode\");\n}\n\n/* -----------------------------------------------------------\n    ENCODE\n----------------------------------------------------------- */\n/**\n * Encodes value to Protocol Buffer binary.\n *\n * Converts a TypeScript value to Protocol Buffer binary format.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertEncode} — Throws on type mismatch\n * - {@link isEncode} — Returns `null` on type mismatch\n * - {@link validateEncode} — Returns detailed validation errors\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n * @param input Value to encode\n * @returns Protocol Buffer binary data\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function encode<T>(input: T): Uint8Array;\n\n/** @internal */\nexport function encode(): never {\n  NoTransformConfigurationError(\"protobuf.encode\");\n}\n\n/**\n * Encodes value to Protocol Buffer binary with assertion.\n *\n * Combines {@link assert} with {@link encode}. Throws {@link TypeGuardError} on\n * type mismatch.\n *\n * Related functions:\n *\n * - {@link encode} — No validation\n * - {@link isEncode} — Returns `null` instead of throwing\n * - {@link validateEncode} — Returns detailed validation errors\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n * @param input Value to encode\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Protocol Buffer binary data\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function assertEncode<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Uint8Array;\n\n/** @internal */\nexport function assertEncode<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Uint8Array;\n\n/** @internal */\nexport function assertEncode(): never {\n  NoTransformConfigurationError(\"protobuf.assertEncode\");\n}\n\n/**\n * Encodes value to Protocol Buffer binary with type checking.\n *\n * Combines {@link is} with {@link encode}. Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link encode} — No validation\n * - {@link assertEncode} — Throws instead of returning `null`\n * - {@link validateEncode} — Returns detailed validation errors\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n * @param input Value to encode\n * @returns Protocol Buffer binary data, or `null` if invalid\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function isEncode<T>(input: T): Uint8Array | null;\n\n/** @internal */\nexport function isEncode<T>(input: unknown): Uint8Array | null;\n\n/** @internal */\nexport function isEncode(): never {\n  NoTransformConfigurationError(\"protobuf.isEncode\");\n}\n\n/**\n * Encodes value to Protocol Buffer binary with validation.\n *\n * Combines {@link validate} with {@link encode}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with binary data.\n *\n * Related functions:\n *\n * - {@link encode} — No validation\n * - {@link assertEncode} — Throws on first error\n * - {@link isEncode} — Returns `null` instead of error details\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n * @param input Value to encode\n * @returns Validation result containing binary data or errors\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function validateEncode<T>(input: T): IValidation<Uint8Array>;\n\n/** @internal */\nexport function validateEncode<T>(input: unknown): IValidation<Uint8Array>;\n\n/** @internal */\nexport function validateEncode(): never {\n  NoTransformConfigurationError(\"protobuf.validateEncode\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link decode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createDecode(): never;\n\n/**\n * Creates reusable {@link decode} function.\n *\n * @template T Target type\n * @returns Reusable decoder function\n */\nexport function createDecode<T>(): (input: Uint8Array) => Resolved<T>;\n\n/** @internal */\nexport function createDecode<T>(): (input: Uint8Array) => Resolved<T> {\n  NoTransformConfigurationError(\"protobuf.createDecode\");\n}\n\n/**\n * Creates reusable {@link isDecode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsDecode(): never;\n\n/**\n * Creates reusable {@link isDecode} function.\n *\n * @template T Target type\n * @returns Reusable decoder function\n */\nexport function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;\n\n/** @internal */\nexport function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null {\n  NoTransformConfigurationError(\"protobuf.createIsDecode\");\n}\n\n/**\n * Creates reusable {@link assertDecode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertDecode(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertDecode} function.\n *\n * @template T Target type\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable decoder function\n */\nexport function createAssertDecode<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => Resolved<T>;\n\n/** @internal */\nexport function createAssertDecode<T>(): (\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => Resolved<T> {\n  NoTransformConfigurationError(\"protobuf.createAssertDecode\");\n}\n\n/**\n * Creates reusable {@link validateDecode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateDecode(): never;\n\n/**\n * Creates reusable {@link validateDecode} function.\n *\n * @template T Target type\n * @returns Reusable decoder function\n */\nexport function createValidateDecode<T>(): (\n  input: Uint8Array,\n) => IValidation<Resolved<T>>;\n\n/** @internal */\nexport function createValidateDecode<T>(): (\n  input: Uint8Array,\n) => IValidation<Resolved<T>> {\n  NoTransformConfigurationError(\"protobuf.createValidateDecode\");\n}\n\n/**\n * Creates reusable {@link encode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createEncode(): never;\n\n/**\n * Creates reusable {@link encode} function.\n *\n * @template T Type of input value\n * @returns Reusable encoder function\n */\nexport function createEncode<T>(): (input: T) => Uint8Array;\n\n/** @internal */\nexport function createEncode<T>(): (input: T) => Uint8Array {\n  NoTransformConfigurationError(\"protobuf.createEncode\");\n}\n\n/**\n * Creates reusable {@link isEncode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsEncode(): never;\n\n/**\n * Creates reusable {@link isEncode} function.\n *\n * @template T Type of input value\n * @returns Reusable encoder function\n */\nexport function createIsEncode<T>(): (input: T) => Uint8Array | null;\n\n/** @internal */\nexport function createIsEncode<T>(): (input: T) => Uint8Array | null {\n  NoTransformConfigurationError(\"protobuf.createIsEncode\");\n}\n\n/**\n * Creates reusable {@link assertEncode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertEncode(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertEncode} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable encoder function\n */\nexport function createAssertEncode<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => Uint8Array;\n\n/** @internal */\nexport function createAssertEncode<T>(): (\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => Uint8Array {\n  NoTransformConfigurationError(\"protobuf.createAssertEncode\");\n}\n\n/**\n * Creates reusable {@link validateEncode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateEncode(): never;\n\n/**\n * Creates reusable {@link validateEncode} function.\n *\n * @template T Type of input value\n * @returns Reusable encoder function\n */\nexport function createValidateEncode<T>(): (\n  input: T,\n) => IValidation<Uint8Array>;\n\n/** @internal */\nexport function createValidateEncode<T>(): (\n  input: T,\n) => IValidation<Uint8Array> {\n  NoTransformConfigurationError(\"protobuf.createValidateEncode\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,UAAiB;CAC/B,8BAA8B,kBAAkB;AAClD;;AAmCA,SAAgB,SAAgB;CAC9B,8BAA8B,iBAAiB;AACjD;;AAyCA,SAAgB,eAAsB;CACpC,8BAA8B,uBAAuB;AACvD;;AA+BA,SAAgB,WAAkB;CAChC,8BAA8B,mBAAmB;AACnD;;AAiCA,SAAgB,iBAAwB;CACtC,8BAA8B,yBAAyB;AACzD;;AA2BA,SAAgB,SAAgB;CAC9B,8BAA8B,iBAAiB;AACjD;;AAqCA,SAAgB,eAAsB;CACpC,8BAA8B,uBAAuB;AACvD;;AA2BA,SAAgB,WAAkB;CAChC,8BAA8B,mBAAmB;AACnD;;AA6BA,SAAgB,iBAAwB;CACtC,8BAA8B,yBAAyB;AACzD;;AAqBA,SAAgB,eAAsD;CACpE,8BAA8B,uBAAuB;AACvD;;AAkBA,SAAgB,iBAA+D;CAC7E,8BAA8B,yBAAyB;AACzD;;AA2BA,SAAgB,qBAGC;CACf,8BAA8B,6BAA6B;AAC7D;;AAoBA,SAAgB,uBAEc;CAC5B,8BAA8B,+BAA+B;AAC/D;;AAkBA,SAAgB,eAA4C;CAC1D,8BAA8B,uBAAuB;AACvD;;AAkBA,SAAgB,iBAAqD;CACnE,8BAA8B,yBAAyB;AACzD;;AA2BA,SAAgB,qBAGA;CACd,8BAA8B,6BAA6B;AAC7D;;AAoBA,SAAgB,uBAEa;CAC3B,8BAA8B,+BAA+B;AAC/D"}
+{"version":3,"file":"protobuf.mjs","names":[],"sources":["../src/protobuf.ts"],"sourcesContent":["import { IValidation, Resolved } from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* ===========================================================\n    PROTOCOL BUFFER\n      - MESSAGE\n      - DECODE\n      - ENCODE\n      - FACTORY FUNCTIONS\n==============================================================\n    SCHEMA\n----------------------------------------------------------- */\n/**\n * Generates Protocol Buffer message schema.\n *\n * @danger You must configure the generic argument `_T`\n */\nexport function message(): never;\n\n/**\n * Generates Protocol Buffer message schema for type `_T`.\n *\n * Creates a `.proto` message definition string from a TypeScript type. Use for\n * sharing schemas with other languages/frameworks.\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template _T Target type\n *\n * @returns Protocol Buffer message schema string\n *\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function message<_T>(): string;\n\n/** @internal */\nexport function message(): never {\n  NoTransformConfigurationError(\"protobuf.message\");\n}\n\n/* -----------------------------------------------------------\n    DECODE\n----------------------------------------------------------- */\n/**\n * Decodes Protocol Buffer binary.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function decode(input: Uint8Array): never;\n\n/**\n * Decodes Protocol Buffer binary to type `T`.\n *\n * Converts Protocol Buffer binary data to a TypeScript instance. Binary data\n * must have been encoded from a `T`-typed value—invalid data causes undefined\n * behavior or errors.\n *\n * For type safety, ensure data was encoded via:\n *\n * - {@link assertEncode} — Encodes with type assertion\n * - {@link isEncode} — Encodes with type checking\n * - {@link validateEncode} — Encodes with validation\n *\n * Note: Decoder validation ({@link assertDecode}, etc.) only checks custom tags\n * like `number & Minimum<7>`, not structural type safety.\n *\n * @template T Target type\n *\n * @param input Protocol Buffer binary data\n *\n * @returns Decoded value of type `T`\n */\nexport function decode<T>(input: Uint8Array): Resolved<T>;\n\n/** @internal */\nexport function decode(): never {\n  NoTransformConfigurationError(\"protobuf.decode\");\n}\n\n/**\n * Decodes Protocol Buffer binary with assertion.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function assertDecode(\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Decodes Protocol Buffer binary with assertion (partial safety).\n *\n * Combines {@link decode} with {@link assert}. Throws {@link TypeGuardError} on\n * validation failure.\n *\n * Warning: Only validates custom tags (e.g., `number & Minimum<7>`, `string &\n * Format<\"uuid\">`), not structural type correctness. Ensure source data was\n * encoded with type-safe encoders.\n *\n * Related functions:\n *\n * - {@link decode} — No validation\n * - {@link isDecode} — Returns `null` instead of throwing\n * - {@link validateDecode} — Returns detailed validation errors\n *\n * @template T Target type\n *\n * @param input Protocol Buffer binary data\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Decoded value of type `T`\n *\n * @throws {TypeGuardError} When custom tag validation fails\n */\nexport function assertDecode<T>(\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Resolved<T>;\n\n/** @internal */\nexport function assertDecode(): never {\n  NoTransformConfigurationError(\"protobuf.assertDecode\");\n}\n\n/**\n * Decodes Protocol Buffer binary with type checking.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function isDecode(input: Uint8Array): never;\n\n/**\n * Decodes Protocol Buffer binary with type checking (partial safety).\n *\n * Combines {@link decode} with {@link is}. Returns `null` on validation failure.\n *\n * Warning: Only validates custom tags (e.g., `number & Minimum<7>`, `string &\n * Format<\"uuid\">`), not structural type correctness. Ensure source data was\n * encoded with type-safe encoders.\n *\n * Related functions:\n *\n * - {@link decode} — No validation\n * - {@link assertDecode} — Throws instead of returning `null`\n * - {@link validateDecode} — Returns detailed validation errors\n *\n * @template T Target type\n *\n * @param input Protocol Buffer binary data\n *\n * @returns Decoded value of type `T`, or `null` if invalid\n */\nexport function isDecode<T>(input: Uint8Array): Resolved<T> | null;\n\n/** @internal */\nexport function isDecode(): never {\n  NoTransformConfigurationError(\"protobuf.isDecode\");\n}\n\n/**\n * Decodes Protocol Buffer binary with validation.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function validateDecode(input: Uint8Array): never;\n\n/**\n * Decodes Protocol Buffer binary with validation (partial safety).\n *\n * Combines {@link decode} with {@link validate}. Returns\n * {@link IValidation.IFailure} with errors on mismatch, or\n * {@link IValidation.ISuccess} with decoded value.\n *\n * Warning: Only validates custom tags (e.g., `number & Minimum<7>`, `string &\n * Format<\"uuid\">`), not structural type correctness. Ensure source data was\n * encoded with type-safe encoders.\n *\n * Related functions:\n *\n * - {@link decode} — No validation\n * - {@link assertDecode} — Throws on first error\n * - {@link isDecode} — Returns `null` instead of error details\n *\n * @template T Target type\n *\n * @param input Protocol Buffer binary data\n *\n * @returns Validation result containing decoded value or errors\n */\nexport function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;\n\n/** @internal */\nexport function validateDecode(): never {\n  NoTransformConfigurationError(\"protobuf.validateDecode\");\n}\n\n/* -----------------------------------------------------------\n    ENCODE\n----------------------------------------------------------- */\n/**\n * Encodes value to Protocol Buffer binary.\n *\n * Converts a TypeScript value to Protocol Buffer binary format.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertEncode} — Throws on type mismatch\n * - {@link isEncode} — Returns `null` on type mismatch\n * - {@link validateEncode} — Returns detailed validation errors\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n *\n * @param input Value to encode\n *\n * @returns Protocol Buffer binary data\n *\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function encode<T>(input: T): Uint8Array;\n\n/** @internal */\nexport function encode(): never {\n  NoTransformConfigurationError(\"protobuf.encode\");\n}\n\n/**\n * Encodes value to Protocol Buffer binary with assertion.\n *\n * Combines {@link assert} with {@link encode}. Throws {@link TypeGuardError} on\n * type mismatch.\n *\n * Related functions:\n *\n * - {@link encode} — No validation\n * - {@link isEncode} — Returns `null` instead of throwing\n * - {@link validateEncode} — Returns detailed validation errors\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n *\n * @param input Value to encode\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Protocol Buffer binary data\n *\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n *\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function assertEncode<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Uint8Array;\n\n/** @internal */\nexport function assertEncode<_T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Uint8Array;\n\n/** @internal */\nexport function assertEncode(): never {\n  NoTransformConfigurationError(\"protobuf.assertEncode\");\n}\n\n/**\n * Encodes value to Protocol Buffer binary with type checking.\n *\n * Combines {@link is} with {@link encode}. Returns `null` on type mismatch.\n *\n * Related functions:\n *\n * - {@link encode} — No validation\n * - {@link assertEncode} — Throws instead of returning `null`\n * - {@link validateEncode} — Returns detailed validation errors\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n *\n * @param input Value to encode\n *\n * @returns Protocol Buffer binary data, or `null` if invalid\n *\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function isEncode<T>(input: T): Uint8Array | null;\n\n/** @internal */\nexport function isEncode<_T>(input: unknown): Uint8Array | null;\n\n/** @internal */\nexport function isEncode(): never {\n  NoTransformConfigurationError(\"protobuf.isEncode\");\n}\n\n/**\n * Encodes value to Protocol Buffer binary with validation.\n *\n * Combines {@link validate} with {@link encode}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with binary data.\n *\n * Related functions:\n *\n * - {@link encode} — No validation\n * - {@link assertEncode} — Throws on first error\n * - {@link isEncode} — Returns `null` instead of error details\n *\n * Protocol Buffer has limited expressiveness compared to TypeScript.\n * Incompatible types cause compilation errors.\n *\n * @template T Type of input value\n *\n * @param input Value to encode\n *\n * @returns Validation result containing binary data or errors\n *\n * @see https://typia.io/docs/protobuf/message/#restrictions\n */\nexport function validateEncode<T>(input: T): IValidation<Uint8Array>;\n\n/** @internal */\nexport function validateEncode<_T>(input: unknown): IValidation<Uint8Array>;\n\n/** @internal */\nexport function validateEncode(): never {\n  NoTransformConfigurationError(\"protobuf.validateEncode\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link decode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createDecode(): never;\n\n/**\n * Creates reusable {@link decode} function.\n *\n * @template T Target type\n *\n * @returns Reusable decoder function\n */\nexport function createDecode<T>(): (input: Uint8Array) => Resolved<T>;\n\n/** @internal */\nexport function createDecode<T>(): (input: Uint8Array) => Resolved<T> {\n  NoTransformConfigurationError(\"protobuf.createDecode\");\n}\n\n/**\n * Creates reusable {@link isDecode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsDecode(): never;\n\n/**\n * Creates reusable {@link isDecode} function.\n *\n * @template T Target type\n *\n * @returns Reusable decoder function\n */\nexport function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;\n\n/** @internal */\nexport function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null {\n  NoTransformConfigurationError(\"protobuf.createIsDecode\");\n}\n\n/**\n * Creates reusable {@link assertDecode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertDecode(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertDecode} function.\n *\n * @template T Target type\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable decoder function\n */\nexport function createAssertDecode<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => Resolved<T>;\n\n/** @internal */\nexport function createAssertDecode<T>(): (\n  input: Uint8Array,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => Resolved<T> {\n  NoTransformConfigurationError(\"protobuf.createAssertDecode\");\n}\n\n/**\n * Creates reusable {@link validateDecode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateDecode(): never;\n\n/**\n * Creates reusable {@link validateDecode} function.\n *\n * @template T Target type\n *\n * @returns Reusable decoder function\n */\nexport function createValidateDecode<T>(): (\n  input: Uint8Array,\n) => IValidation<Resolved<T>>;\n\n/** @internal */\nexport function createValidateDecode<T>(): (\n  input: Uint8Array,\n) => IValidation<Resolved<T>> {\n  NoTransformConfigurationError(\"protobuf.createValidateDecode\");\n}\n\n/**\n * Creates reusable {@link encode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createEncode(): never;\n\n/**\n * Creates reusable {@link encode} function.\n *\n * @template T Type of input value\n *\n * @returns Reusable encoder function\n */\nexport function createEncode<T>(): (input: T) => Uint8Array;\n\n/** @internal */\nexport function createEncode<T>(): (input: T) => Uint8Array {\n  NoTransformConfigurationError(\"protobuf.createEncode\");\n}\n\n/**\n * Creates reusable {@link isEncode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsEncode(): never;\n\n/**\n * Creates reusable {@link isEncode} function.\n *\n * @template T Type of input value\n *\n * @returns Reusable encoder function\n */\nexport function createIsEncode<T>(): (input: T) => Uint8Array | null;\n\n/** @internal */\nexport function createIsEncode<T>(): (input: T) => Uint8Array | null {\n  NoTransformConfigurationError(\"protobuf.createIsEncode\");\n}\n\n/**\n * Creates reusable {@link assertEncode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertEncode(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertEncode} function.\n *\n * @template T Type of input value\n *\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n *\n * @returns Reusable encoder function\n */\nexport function createAssertEncode<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => Uint8Array;\n\n/** @internal */\nexport function createAssertEncode<T>(): (\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n) => Uint8Array {\n  NoTransformConfigurationError(\"protobuf.createAssertEncode\");\n}\n\n/**\n * Creates reusable {@link validateEncode} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateEncode(): never;\n\n/**\n * Creates reusable {@link validateEncode} function.\n *\n * @template T Type of input value\n *\n * @returns Reusable encoder function\n */\nexport function createValidateEncode<T>(): (\n  input: T,\n) => IValidation<Uint8Array>;\n\n/** @internal */\nexport function createValidateEncode<T>(): (\n  input: T,\n) => IValidation<Uint8Array> {\n  NoTransformConfigurationError(\"protobuf.createValidateEncode\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,UAAiB;CAC/B,8BAA8B,kBAAkB;AAClD;;AAqCA,SAAgB,SAAgB;CAC9B,8BAA8B,iBAAiB;AACjD;;AA4CA,SAAgB,eAAsB;CACpC,8BAA8B,uBAAuB;AACvD;;AAiCA,SAAgB,WAAkB;CAChC,8BAA8B,mBAAmB;AACnD;;AAmCA,SAAgB,iBAAwB;CACtC,8BAA8B,yBAAyB;AACzD;;AA8BA,SAAgB,SAAgB;CAC9B,8BAA8B,iBAAiB;AACjD;;AAyCA,SAAgB,eAAsB;CACpC,8BAA8B,uBAAuB;AACvD;;AA8BA,SAAgB,WAAkB;CAChC,8BAA8B,mBAAmB;AACnD;;AAgCA,SAAgB,iBAAwB;CACtC,8BAA8B,yBAAyB;AACzD;;AAsBA,SAAgB,eAAsD;CACpE,8BAA8B,uBAAuB;AACvD;;AAmBA,SAAgB,iBAA+D;CAC7E,8BAA8B,yBAAyB;AACzD;;AA6BA,SAAgB,qBAGC;CACf,8BAA8B,6BAA6B;AAC7D;;AAqBA,SAAgB,uBAEc;CAC5B,8BAA8B,+BAA+B;AAC/D;;AAmBA,SAAgB,eAA4C;CAC1D,8BAA8B,uBAAuB;AACvD;;AAmBA,SAAgB,iBAAqD;CACnE,8BAA8B,yBAAyB;AACzD;;AA6BA,SAAgB,qBAGA;CACd,8BAA8B,6BAA6B;AAC7D;;AAqBA,SAAgB,uBAEa;CAC3B,8BAA8B,+BAA+B;AAC/D"}

package/lib/reflect.d.ts

@@ -2,7 +2,7 @@ import { Atomic, IMetadataSchemaCollection, IMetadataSchemaUnit } from "@typia/i
 /**
  * Generates metadata schemas for multiple types.
  *
- * @danger You must configure the generic argument `Types`
+ * @danger You must configure the generic argument `_Types`
  */
 export declare function schemas(): never;
 /**
@@ -12,14 +12,15 @@ export declare function schemas(): never;
  * the tuple. Collection types (Array, Tuple, Object) are stored in
  * `components`. Alias types are stored in `aliases`.
  *
- * @template Types Tuple of target types
+ * @template _Types Tuple of target types
+ *
  * @returns Metadata schema collection
  */
-export declare function schemas<Types extends unknown[]>(): IMetadataSchemaCollection;
+export declare function schemas<_Types extends unknown[]>(): IMetadataSchemaCollection;
 /**
  * Generates metadata schema for a single type.
  *
- * @danger You must configure the generic argument `Type`
+ * @danger You must configure the generic argument `_Type`
  */
 export declare function schema(): never;
 /**
@@ -27,26 +28,28 @@ export declare function schema(): never;
  *
  * Creates {@link IMetadataSchemaUnit} containing metadata for the type.
  *
- * @template Type Target type
+ * @template _Type Target type
+ *
  * @returns Metadata schema unit
  */
-export declare function schema<Type>(): IMetadataSchemaUnit;
+export declare function schema<_Type>(): IMetadataSchemaUnit;
 /**
- * Gets the runtime type name of type `T`.
+ * Gets the runtime type name of type `_T`.
  *
- * @danger You must configure the generic argument `T`
+ * @danger You must configure the generic argument `_T`
  */
 export declare function name(): never;
 /**
- * Gets the runtime type name of type `T`.
+ * Gets the runtime type name of type `_T`.
  *
  * Returns a string representation of the type name.
  *
- * @template T Target type
- * @template Regular If `true`, returns regular (normalized) name
+ * @template _T Target type
+ * @template _Regular If `true`, returns regular (normalized) name
+ *
  * @returns Type name string
  */
-export declare function name<T, Regular extends boolean = false>(): string;
+export declare function name<_T, _Regular extends boolean = false>(): string;
 /**
  * Converts union literal type to array.
  *
@@ -59,6 +62,7 @@ export declare function literals(): never;
  * Extracts all members of a union literal type `T` into an array at runtime.
  *
  * @template T Union literal type (e.g., `"A" | "B" | 1`)
+ *
  * @returns Array containing all union members
  */
 export declare function literals<T extends Atomic.Type | null>(): T[];

package/lib/reflect.js.map

@@ -1 +1 @@
-{"version":3,"file":"reflect.js","sourceRoot":"","sources":["../src/reflect.ts"],"names":[],"mappings":";;;;;;AAMA,gGAA6F;AAqB7F,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAoBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAmBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AACpD,CAAC"}
+{"version":3,"file":"reflect.js","sourceRoot":"","sources":["../src/reflect.ts"],"names":[],"mappings":";;;;;;AAMA,gGAA6F;AAsB7F,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,iBAAiB,CAAC,CAAC;AACnD,CAAC;AAoBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,gBAAgB,CAAC,CAAC;AAClD,CAAC;AAqBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAoBD,gBAAgB;AAChB;IACE,IAAA,6DAA6B,EAAC,kBAAkB,CAAC,CAAC;AACpD,CAAC"}

package/lib/reflect.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"reflect.mjs","names":[],"sources":["../src/reflect.ts"],"sourcesContent":["import {\n  Atomic,\n  IMetadataSchemaCollection,\n  IMetadataSchemaUnit,\n} from \"@typia/interface\";\n\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/**\n * Generates metadata schemas for multiple types.\n *\n * @danger You must configure the generic argument `Types`\n */\nexport function schemas(): never;\n\n/**\n * Generates metadata schemas for multiple types.\n *\n * Creates {@link IMetadataSchemaCollection} containing metadata for all types in\n * the tuple. Collection types (Array, Tuple, Object) are stored in\n * `components`. Alias types are stored in `aliases`.\n *\n * @template Types Tuple of target types\n * @returns Metadata schema collection\n */\nexport function schemas<Types extends unknown[]>(): IMetadataSchemaCollection;\n\n/** @internal */\nexport function schemas(): never {\n  NoTransformConfigurationError(\"reflect.schemas\");\n}\n\n/**\n * Generates metadata schema for a single type.\n *\n * @danger You must configure the generic argument `Type`\n */\nexport function schema(): never;\n\n/**\n * Generates metadata schema for a single type.\n *\n * Creates {@link IMetadataSchemaUnit} containing metadata for the type.\n *\n * @template Type Target type\n * @returns Metadata schema unit\n */\nexport function schema<Type>(): IMetadataSchemaUnit;\n\n/** @internal */\nexport function schema(): never {\n  NoTransformConfigurationError(\"reflect.schema\");\n}\n\n/**\n * Gets the runtime type name of type `T`.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function name(): never;\n\n/**\n * Gets the runtime type name of type `T`.\n *\n * Returns a string representation of the type name.\n *\n * @template T Target type\n * @template Regular If `true`, returns regular (normalized) name\n * @returns Type name string\n */\nexport function name<T, Regular extends boolean = false>(): string;\n\n/** @internal */\nexport function name(): never {\n  NoTransformConfigurationError(\"reflect.name\");\n}\n\n/**\n * Converts union literal type to array.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function literals(): never;\n\n/**\n * Converts union literal type to array.\n *\n * Extracts all members of a union literal type `T` into an array at runtime.\n *\n * @template T Union literal type (e.g., `\"A\" | \"B\" | 1`)\n * @returns Array containing all union members\n */\nexport function literals<T extends Atomic.Type | null>(): T[];\n\n/** @internal */\nexport function literals(): never {\n  NoTransformConfigurationError(\"reflect.literals\");\n}\n"],"mappings":";;;;;;;;;;AA4BA,SAAgB,UAAiB;CAC/B,8BAA8B,iBAAiB;AACjD;;AAoBA,SAAgB,SAAgB;CAC9B,8BAA8B,gBAAgB;AAChD;;AAqBA,SAAgB,OAAc;CAC5B,8BAA8B,cAAc;AAC9C;;AAoBA,SAAgB,WAAkB;CAChC,8BAA8B,kBAAkB;AAClD"}
+{"version":3,"file":"reflect.mjs","names":[],"sources":["../src/reflect.ts"],"sourcesContent":["import {\n  Atomic,\n  IMetadataSchemaCollection,\n  IMetadataSchemaUnit,\n} from \"@typia/interface\";\n\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/**\n * Generates metadata schemas for multiple types.\n *\n * @danger You must configure the generic argument `_Types`\n */\nexport function schemas(): never;\n\n/**\n * Generates metadata schemas for multiple types.\n *\n * Creates {@link IMetadataSchemaCollection} containing metadata for all types in\n * the tuple. Collection types (Array, Tuple, Object) are stored in\n * `components`. Alias types are stored in `aliases`.\n *\n * @template _Types Tuple of target types\n *\n * @returns Metadata schema collection\n */\nexport function schemas<_Types extends unknown[]>(): IMetadataSchemaCollection;\n\n/** @internal */\nexport function schemas(): never {\n  NoTransformConfigurationError(\"reflect.schemas\");\n}\n\n/**\n * Generates metadata schema for a single type.\n *\n * @danger You must configure the generic argument `_Type`\n */\nexport function schema(): never;\n\n/**\n * Generates metadata schema for a single type.\n *\n * Creates {@link IMetadataSchemaUnit} containing metadata for the type.\n *\n * @template _Type Target type\n *\n * @returns Metadata schema unit\n */\nexport function schema<_Type>(): IMetadataSchemaUnit;\n\n/** @internal */\nexport function schema(): never {\n  NoTransformConfigurationError(\"reflect.schema\");\n}\n\n/**\n * Gets the runtime type name of type `_T`.\n *\n * @danger You must configure the generic argument `_T`\n */\nexport function name(): never;\n\n/**\n * Gets the runtime type name of type `_T`.\n *\n * Returns a string representation of the type name.\n *\n * @template _T Target type\n * @template _Regular If `true`, returns regular (normalized) name\n *\n * @returns Type name string\n */\nexport function name<_T, _Regular extends boolean = false>(): string;\n\n/** @internal */\nexport function name(): never {\n  NoTransformConfigurationError(\"reflect.name\");\n}\n\n/**\n * Converts union literal type to array.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function literals(): never;\n\n/**\n * Converts union literal type to array.\n *\n * Extracts all members of a union literal type `T` into an array at runtime.\n *\n * @template T Union literal type (e.g., `\"A\" | \"B\" | 1`)\n *\n * @returns Array containing all union members\n */\nexport function literals<T extends Atomic.Type | null>(): T[];\n\n/** @internal */\nexport function literals(): never {\n  NoTransformConfigurationError(\"reflect.literals\");\n}\n"],"mappings":";;;;;;;;;;AA6BA,SAAgB,UAAiB;CAC/B,8BAA8B,iBAAiB;AACjD;;AAqBA,SAAgB,SAAgB;CAC9B,8BAA8B,gBAAgB;AAChD;;AAsBA,SAAgB,OAAc;CAC5B,8BAA8B,cAAc;AAC9C;;AAqBA,SAAgB,WAAkB;CAChC,8BAA8B,kBAAkB;AAClD"}

package/lib/transform.d.ts

@@ -1,3 +1,20 @@
 import type { ITtscPlugin, ITtscPluginFactoryContext } from "ttsc";
+/**
+ * Describe typia's native transform to ttsc.
+ *
+ * Ttsc loads this file as an ES module, where `require` is unavailable, so a
+ * resolver is anchored on the consuming project to find typia's own package
+ * root. The returned descriptor names the plugin and the Go command under
+ * `native/cmd/ttsc-typia`; the transform itself is not written in TypeScript.
+ *
+ * @param context Plugin factory context of ttsc
+ *
+ * @returns Plugin descriptor
+ *
+ * @evidence contracts/common.md#principled-implementation The ttsc loader runs this file as an ES module where `require` is absent, so the function builds a CommonJS resolver anchored at the consuming project and resolves typia's own `package.json`, whose directory holds the native sources; the returned descriptor names the plugin and the Go command directory under `native/cmd/ttsc-typia`.
+ * @evidence contracts/common.md#clear-and-simple-design One function that returns a two-field descriptor and no transformer; the default export repeats the same function for loaders that read it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The package root comes from the installed typia through the supported resolver and not from path substrings, so it works for npm consumers and workspaces alike; the transform itself stays in Go.
+ * @evidence contracts/common.md#meaningful-documentation A comment explains the purpose, the ESM resolution reason and the descriptor.
+ */
 export declare function createTtscPlugin(context: ITtscPluginFactoryContext): ITtscPlugin;
 export default createTtscPlugin;

package/lib/transform.js

@@ -6,6 +6,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTtscPlugin = createTtscPlugin;
 const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Describe typia's native transform to ttsc.
+ *
+ * Ttsc loads this file as an ES module, where `require` is unavailable, so a
+ * resolver is anchored on the consuming project to find typia's own package
+ * root. The returned descriptor names the plugin and the Go command under
+ * `native/cmd/ttsc-typia`; the transform itself is not written in TypeScript.
+ *
+ * @param context Plugin factory context of ttsc
+ *
+ * @returns Plugin descriptor
+ *
+ * @evidence contracts/common.md#principled-implementation The ttsc loader runs this file as an ES module where `require` is absent, so the function builds a CommonJS resolver anchored at the consuming project and resolves typia's own `package.json`, whose directory holds the native sources; the returned descriptor names the plugin and the Go command directory under `native/cmd/ttsc-typia`.
+ * @evidence contracts/common.md#clear-and-simple-design One function that returns a two-field descriptor and no transformer; the default export repeats the same function for loaders that read it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The package root comes from the installed typia through the supported resolver and not from path substrings, so it works for npm consumers and workspaces alike; the transform itself stays in Go.
+ * @evidence contracts/common.md#meaningful-documentation A comment explains the purpose, the ESM resolution reason and the descriptor.
+ */
 function createTtscPlugin(context) {
     // ttsc loads this descriptor as ESM, where the ambient `require` is
     // unavailable; anchor a CJS resolver on the consuming project to locate

package/lib/transform.js.map

@@ -1 +1 @@
-{"version":3,"file":"transform.js","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA4C;AAC5C,0DAA6B;AAG7B,0BACE,OAAkC;IAElC,oEAAoE;IACpE,wEAAwE;IACxE,2EAA2E;IAC3E,MAAM,WAAW,GAAG,IAAA,2BAAa,EAC/B,mBAAI,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,cAAc,CAAC,CAC/C,CAAC;IACF,MAAM,IAAI,GAAW,mBAAI,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAC7E,OAAO;QACL,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,mBAAI,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,CAAC;KAC1D,CAAC;AACJ,CAAC;kBAEc,gBAAgB"}
+{"version":3,"file":"transform.js","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA4C;AAC5C,0DAA6B;AAG7B;;;;;;;;;;;;;;;;GAgBG;AACH,0BACE,OAAkC;IAElC,oEAAoE;IACpE,wEAAwE;IACxE,2EAA2E;IAC3E,MAAM,WAAW,GAAG,IAAA,2BAAa,EAC/B,mBAAI,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,cAAc,CAAC,CAC/C,CAAC;IACF,MAAM,IAAI,GAAW,mBAAI,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAC7E,OAAO;QACL,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,mBAAI,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,CAAC;KAC1D,CAAC;AACJ,CAAC;kBAEc,gBAAgB"}

package/lib/transform.mjs

@@ -1,6 +1,23 @@
 import { createRequire } from "node:module";
 import path from "node:path";
 //#region src/transform.ts
+/**
+* Describe typia's native transform to ttsc.
+*
+* Ttsc loads this file as an ES module, where `require` is unavailable, so a
+* resolver is anchored on the consuming project to find typia's own package
+* root. The returned descriptor names the plugin and the Go command under
+* `native/cmd/ttsc-typia`; the transform itself is not written in TypeScript.
+*
+* @param context Plugin factory context of ttsc
+*
+* @returns Plugin descriptor
+*
+* @evidence contracts/common.md#principled-implementation The ttsc loader runs this file as an ES module where `require` is absent, so the function builds a CommonJS resolver anchored at the consuming project and resolves typia's own `package.json`, whose directory holds the native sources; the returned descriptor names the plugin and the Go command directory under `native/cmd/ttsc-typia`.
+* @evidence contracts/common.md#clear-and-simple-design One function that returns a two-field descriptor and no transformer; the default export repeats the same function for loaders that read it.
+* @evidence contracts/common.md#prohibited-implementation-shortcuts The package root comes from the installed typia through the supported resolver and not from path substrings, so it works for npm consumers and workspaces alike; the transform itself stays in Go.
+* @evidence contracts/common.md#meaningful-documentation A comment explains the purpose, the ESM resolution reason and the descriptor.
+*/
 function createTtscPlugin(context) {
 	const requireFrom = createRequire(path.join(context.projectRoot, "package.json"));
 	const root = path.dirname(requireFrom.resolve("typia/package.json"));

package/lib/transform.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"transform.mjs","names":[],"sources":["../src/transform.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\nimport path from \"node:path\";\nimport type { ITtscPlugin, ITtscPluginFactoryContext } from \"ttsc\";\n\nexport function createTtscPlugin(\n  context: ITtscPluginFactoryContext,\n): ITtscPlugin {\n  // ttsc loads this descriptor as ESM, where the ambient `require` is\n  // unavailable; anchor a CJS resolver on the consuming project to locate\n  // typia's own package root (not the project root, which has no `native/`).\n  const requireFrom = createRequire(\n    path.join(context.projectRoot, \"package.json\"),\n  );\n  const root: string = path.dirname(requireFrom.resolve(\"typia/package.json\"));\n  return {\n    name: \"typia\",\n    source: path.resolve(root, \"native\", \"cmd\", \"ttsc-typia\"),\n  };\n}\n\nexport default createTtscPlugin;\n"],"mappings":";;;AAIA,SAAgB,iBACd,SACa;CAIb,MAAM,cAAc,cAClB,KAAK,KAAK,QAAQ,aAAa,cAAc,CAC/C;CACA,MAAM,OAAe,KAAK,QAAQ,YAAY,QAAQ,oBAAoB,CAAC;CAC3E,OAAO;EACL,MAAM;EACN,QAAQ,KAAK,QAAQ,MAAM,UAAU,OAAO,YAAY;CAC1D;AACF"}
+{"version":3,"file":"transform.mjs","names":[],"sources":["../src/transform.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\nimport path from \"node:path\";\nimport type { ITtscPlugin, ITtscPluginFactoryContext } from \"ttsc\";\n\n/**\n * Describe typia's native transform to ttsc.\n *\n * Ttsc loads this file as an ES module, where `require` is unavailable, so a\n * resolver is anchored on the consuming project to find typia's own package\n * root. The returned descriptor names the plugin and the Go command under\n * `native/cmd/ttsc-typia`; the transform itself is not written in TypeScript.\n *\n * @param context Plugin factory context of ttsc\n *\n * @returns Plugin descriptor\n *\n * @evidence contracts/common.md#principled-implementation The ttsc loader runs this file as an ES module where `require` is absent, so the function builds a CommonJS resolver anchored at the consuming project and resolves typia's own `package.json`, whose directory holds the native sources; the returned descriptor names the plugin and the Go command directory under `native/cmd/ttsc-typia`.\n * @evidence contracts/common.md#clear-and-simple-design One function that returns a two-field descriptor and no transformer; the default export repeats the same function for loaders that read it.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The package root comes from the installed typia through the supported resolver and not from path substrings, so it works for npm consumers and workspaces alike; the transform itself stays in Go.\n * @evidence contracts/common.md#meaningful-documentation A comment explains the purpose, the ESM resolution reason and the descriptor.\n */\nexport function createTtscPlugin(\n  context: ITtscPluginFactoryContext,\n): ITtscPlugin {\n  // ttsc loads this descriptor as ESM, where the ambient `require` is\n  // unavailable; anchor a CJS resolver on the consuming project to locate\n  // typia's own package root (not the project root, which has no `native/`).\n  const requireFrom = createRequire(\n    path.join(context.projectRoot, \"package.json\"),\n  );\n  const root: string = path.dirname(requireFrom.resolve(\"typia/package.json\"));\n  return {\n    name: \"typia\",\n    source: path.resolve(root, \"native\", \"cmd\", \"ttsc-typia\"),\n  };\n}\n\nexport default createTtscPlugin;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,iBACd,SACa;CAIb,MAAM,cAAc,cAClB,KAAK,KAAK,QAAQ,aAAa,cAAc,CAC/C;CACA,MAAM,OAAe,KAAK,QAAQ,YAAY,QAAQ,oBAAoB,CAAC;CAC3E,OAAO;EACL,MAAM;EACN,QAAQ,KAAK,QAAQ,MAAM,UAAU,OAAO,YAAY;CAC1D;AACF"}

package/native/adapter/adapter.go

@@ -4,13 +4,38 @@ import (
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
 )
 
+// PluginOptions holds the typia options resolved from the ttsc plugin entry.
+//
+// Functional, Numeric and Finite are plain switches that are on only when the
+// entry sets them to true. Undefined is a pointer because `undefined: false` is
+// a distinct setting from leaving it unset.
+//
+// @evidence contracts/common.md#principled-implementation Three switches are plain booleans because only `true` enables them, and `undefined` is a pointer because the exactOptionalPropertyTypes workflow needs to tell an explicit false from an omitted value; the zero value is typia's documented default.
+// @evidence contracts/common.md#clear-and-simple-design A four-field record built by ReadPluginOptions and consumed by one conversion method.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts It holds values read from the host's resolved entry and applies no environment or fixture override.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field means and why Undefined is a pointer.
 type PluginOptions struct {
+  // Functional enables function-type validation; false leaves the option unset.
   Functional bool
-  Numeric    bool
-  Finite     bool
-  Undefined  *bool
+
+  // Numeric enables NaN rejection in validators; false leaves it unset.
+  Numeric bool
+
+  // Finite enables non-finite number rejection; false leaves it unset.
+  Finite bool
+
+  // Undefined distinguishes an omitted option from explicit false or true.
+  Undefined *bool
 }
 
+// TransformOptions converts the options to the transform's option record: a
+// switch that is off becomes nil, an unset Undefined stays nil and the runtime is
+// always "typia".
+//
+// @evidence contracts/common.md#principled-implementation A false switch maps to nil and a true one to a pointer to true, so the transform sees "not set" for both false and omitted, which is how its three on/off options have always been read; Undefined is passed through unchanged to keep false distinct, and the runtime is fixed to `typia`.
+// @evidence contracts/common.md#clear-and-simple-design One value-receiver method and a private pointer helper.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The mapping is the option contract and no consumer is special-cased.
+// @evidence contracts/common.md#meaningful-documentation The doc states the nil mapping and the fixed runtime.
 func (p PluginOptions) TransformOptions() nativecontext.ITransformOptions {
   return nativecontext.ITransformOptions{
     Finite:     boolPointer(p.Finite),

package/native/adapter/adapter_options_branch_matrix_test.go

@@ -15,40 +15,45 @@ import "testing"
 // 2. Convert true options and verify each boolean pointer is populated.
 // 3. Preserve an explicitly supplied undefined pointer.
 // 4. Exercise boolPointer directly for both branches.
+//
+// @evidence contracts/testing.md#behavioral-verification The adapter option conversion is called on zero-value options and on enabled options; false flags must stay nil and enabled values and the tri-state undefined option must be forwarded.
+// @evidence contracts/testing.md#independent-expectations The adapter contract (false is indistinguishable from absent, true and the tri-state undefined are forwarded) supplies the authored expectations.
+// @evidence contracts/testing.md#distinguishing-cases Zero options and enabled options are the two rows; individual flag combinations are owned by the public adapter options test.
+// @evidence contracts/testing.md#execution-ownership The typia_native_internal Go command (go -C packages/typia/test test -tags typia_native_internal ../native/...) runs this same-package Test function in process. The tagged test calls the exported conversion in memory with no filesystem fixture, process or native command build.
 func TestAdapterOptionsBranchMatrix(t *testing.T) {
-	zero := PluginOptions{}.TransformOptions()
-	if zero.Runtime != "typia" ||
-		zero.Finite != nil ||
-		zero.Numeric != nil ||
-		zero.Functional != nil ||
-		zero.Undefined != nil {
-		t.Fatalf("zero plugin options should keep false flags nil: %#v", zero)
-	}
+  zero := PluginOptions{}.TransformOptions()
+  if zero.Runtime != "typia" ||
+    zero.Finite != nil ||
+    zero.Numeric != nil ||
+    zero.Functional != nil ||
+    zero.Undefined != nil {
+    t.Fatalf("zero plugin options should keep false flags nil: %#v", zero)
+  }
 
-	undefined := false
-	enabled := PluginOptions{
-		Functional: true,
-		Numeric:    true,
-		Finite:     true,
-		Undefined:  &undefined,
-	}.TransformOptions()
-	if enabled.Runtime != "typia" ||
-		enabled.Finite == nil ||
-		enabled.Numeric == nil ||
-		enabled.Functional == nil ||
-		enabled.Undefined != &undefined {
-		t.Fatalf("enabled plugin options were not forwarded: %#v", enabled)
-	}
-	if *enabled.Finite != true ||
-		*enabled.Numeric != true ||
-		*enabled.Functional != true ||
-		*enabled.Undefined != false {
-		t.Fatalf("enabled plugin option values changed: %#v", enabled)
-	}
-	if boolPointer(false) != nil {
-		t.Fatal("false option should not allocate a pointer")
-	}
-	if value := boolPointer(true); value == nil || *value != true {
-		t.Fatal("true option should allocate a true pointer")
-	}
+  undefined := false
+  enabled := PluginOptions{
+    Functional: true,
+    Numeric:    true,
+    Finite:     true,
+    Undefined:  &undefined,
+  }.TransformOptions()
+  if enabled.Runtime != "typia" ||
+    enabled.Finite == nil ||
+    enabled.Numeric == nil ||
+    enabled.Functional == nil ||
+    enabled.Undefined != &undefined {
+    t.Fatalf("enabled plugin options were not forwarded: %#v", enabled)
+  }
+  if *enabled.Finite != true ||
+    *enabled.Numeric != true ||
+    *enabled.Functional != true ||
+    *enabled.Undefined != false {
+    t.Fatalf("enabled plugin option values changed: %#v", enabled)
+  }
+  if boolPointer(false) != nil {
+    t.Fatal("false option should not allocate a pointer")
+  }
+  if value := boolPointer(true); value == nil || *value != true {
+    t.Fatal("true option should allocate a true pointer")
+  }
 }

package/native/adapter/plugin_options.go

@@ -40,6 +40,11 @@ const PluginName = "typia"
 // An absent or empty payload yields the zero options, which are typia's
 // documented defaults. That is not a guess: a host that hands typia no entry
 // has stated that typia was configured with nothing.
+//
+// @evidence contracts/common.md#principled-implementation The ordered plugin payload that the host resolved from tsconfig is decoded, the entry with typia's name is selected and its config is read, so inherited and commented-out settings are handled by the host's own JSONC and extends resolution instead of a second parse; an absent or empty payload means no configuration, and an undecodable one is an error rather than silent defaults.
+// @evidence contracts/common.md#clear-and-simple-design A short function over three private helpers, one each for decoding, entry lookup and boolean reading.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts There is no fallback that rereads tsconfig.json, which the doc records as the cause of an earlier defect; a non-boolean option is treated as omitted and never coerced.
+// @evidence contracts/common.md#meaningful-documentation The doc explains why the payload is the only authority and what the empty case means.
 func ReadPluginOptions(pluginsJSON string) (PluginOptions, error) {
   entries, err := parsePluginEntries(pluginsJSON)
   if err != nil {

package/native/adapter/plugin_options_payload_matrix_test.go

@@ -19,6 +19,11 @@ import (
 //  1. Feed the reader each payload shape the host can produce.
 //  2. Assert the three on/off options and the tri-state `undefined` option.
 //  3. Cover the sibling-entry, missing-entry, and empty-payload boundaries.
+//
+// @evidence contracts/testing.md#behavioral-verification ReadPluginOptions is called with authored host payloads: the plugin's own entry with on, off and undefined options, payloads carrying other plugins' entries, and an undecodable payload; options must equal the authored table and a bad payload must be an error.
+// @evidence contracts/testing.md#independent-expectations The host contract (it hands each plugin its own entry) and the authored payload table decide every expected option; defaults are not read from the decoder.
+// @evidence contracts/testing.md#distinguishing-cases Own-entry options in both directions, foreign entries that must be ignored and the error case form the matrix.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It decodes in-memory JSON payloads with no filesystem fixture, process or native command build.
 func TestReadPluginOptionsPayloadMatrix(t *testing.T) {
   truth := true
   lie := false