typia 13.0.1-dev.20260703.1 → 13.0.2

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"}

package/lib/plain.mjs

@@ -1,3 +1,119 @@
-export { assertClassify, assertClone, assertPrune, classify, clone, createAssertClassify, createAssertClone, createAssertPrune, createClassify, createClone, createIsClone, createIsPrune, createPrune, createValidateClassify, createValidateClone, createValidatePrune, isClone, isPrune, prune, validateClassify, validateClone, validatePrune } from './plain2.mjs';
-export { __exports as default } from './_virtual/plain.mjs';
-//# sourceMappingURL=plain.mjs.map
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/plain.ts
+var plain_exports = /* @__PURE__ */ __exportAll({
+	assertClassify: () => assertClassify,
+	assertClone: () => assertClone,
+	assertPrune: () => assertPrune,
+	classify: () => classify,
+	clone: () => clone,
+	createAssertClassify: () => createAssertClassify,
+	createAssertClone: () => createAssertClone,
+	createAssertPrune: () => createAssertPrune,
+	createClassify: () => createClassify,
+	createClone: () => createClone,
+	createIsClone: () => createIsClone,
+	createIsPrune: () => createIsPrune,
+	createPrune: () => createPrune,
+	createValidateClassify: () => createValidateClassify,
+	createValidateClone: () => createValidateClone,
+	createValidatePrune: () => createValidatePrune,
+	isClone: () => isClone,
+	isPrune: () => isPrune,
+	prune: () => prune,
+	validateClassify: () => validateClassify,
+	validateClone: () => validateClone,
+	validatePrune: () => validatePrune
+});
+/** @internal */
+function clone() {
+	NoTransformConfigurationError("plain.clone");
+}
+/** @internal */
+function assertClone() {
+	NoTransformConfigurationError("plain.assertClone");
+}
+/** @internal */
+function isClone() {
+	NoTransformConfigurationError("plain.isClone");
+}
+/** @internal */
+function validateClone() {
+	NoTransformConfigurationError("plain.validateClone");
+}
+/** @internal */
+function prune() {
+	NoTransformConfigurationError("plain.prune");
+}
+/** @internal */
+function assertPrune() {
+	NoTransformConfigurationError("plain.assertPrune");
+}
+/** @internal */
+function isPrune() {
+	NoTransformConfigurationError("plain.isPrune");
+}
+/** @internal */
+function validatePrune() {
+	NoTransformConfigurationError("plain.validatePrune");
+}
+/** @internal */
+function classify() {
+	NoTransformConfigurationError("plain.classify");
+}
+/** @internal */
+function assertClassify() {
+	NoTransformConfigurationError("plain.assertClassify");
+}
+/** @internal */
+function validateClassify() {
+	NoTransformConfigurationError("plain.validateClassify");
+}
+/** @internal */
+function createClone() {
+	NoTransformConfigurationError("plain.createClone");
+}
+/** @internal */
+function createAssertClone() {
+	NoTransformConfigurationError("plain.createAssertClone");
+}
+/** @internal */
+function createIsClone() {
+	NoTransformConfigurationError("plain.createIsClone");
+}
+/** @internal */
+function createValidateClone() {
+	NoTransformConfigurationError("plain.createValidateClone");
+}
+/** @internal */
+function createPrune() {
+	NoTransformConfigurationError("plain.createPrune");
+}
+/** @internal */
+function createAssertPrune() {
+	NoTransformConfigurationError("plain.createAssertPrune");
+}
+/** @internal */
+function createIsPrune() {
+	NoTransformConfigurationError("plain.createIsPrune");
+}
+/** @internal */
+function createValidatePrune() {
+	NoTransformConfigurationError("plain.createValidatePrune");
+}
+/** @internal */
+function createClassify() {
+	NoTransformConfigurationError("plain.createClassify");
+}
+/** @internal */
+function createAssertClassify() {
+	NoTransformConfigurationError("plain.createAssertClassify");
+}
+/** @internal */
+function createValidateClassify() {
+	NoTransformConfigurationError("plain.createValidateClassify");
+}
+//#endregion
+export { assertClassify, assertClone, assertPrune, classify, clone, createAssertClassify, createAssertClone, createAssertPrune, createClassify, createClone, createIsClone, createIsPrune, createPrune, createValidateClassify, createValidateClone, createValidatePrune, isClone, isPrune, plain_exports, prune, validateClassify, validateClone, validatePrune };
+
+//# sourceMappingURL=plain.mjs.map

package/lib/plain.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"plain.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"plain.mjs","names":[],"sources":["../src/plain.ts"],"sourcesContent":["/* ===========================================================\n    PLAIN\n      - CLONE\n      - PRUNE\n      - CLASSIFY\n      - FACTORY FUNCTIONS\n=========================================================== */\nimport {\n  Classifiable,\n  ClassifyResult,\n  IValidation,\n  Resolved,\n} from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\n/* -----------------------------------------------------------\n    CLONE\n----------------------------------------------------------- */\n/**\n * Deep clones value of type `T`.\n *\n * Creates a deep copy of the input value. Class instances with methods are\n * cloned as plain objects (methods are not copied).\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertClone} — Throws on type mismatch\n * - {@link isClone} — Returns `null` on type mismatch\n * - {@link validateClone} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to clone\n * @returns Deep cloned value\n */\nexport function clone<T>(input: T): Resolved<T>;\n\n/** @internal */\nexport function clone(): never {\n  NoTransformConfigurationError(\"plain.clone\");\n}\n\n/**\n * Deep clones value with assertion.\n *\n * Creates a deep copy with {@link assert} validation. Throws\n * {@link TypeGuardError} on type mismatch. Class instances with methods are\n * cloned as plain objects.\n *\n * Related functions:\n *\n * - {@link clone} — No validation\n * - {@link isClone} — Returns `null` instead of throwing\n * - {@link validateClone} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to clone\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Deep cloned value\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertClone<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Resolved<T>;\n\n/** @internal */\nexport function assertClone<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): Resolved<T>;\n\n/** @internal */\nexport function assertClone(): never {\n  NoTransformConfigurationError(\"plain.assertClone\");\n}\n\n/**\n * Deep clones value with type checking.\n *\n * Creates a deep copy with {@link is} validation. Returns `null` on type\n * mismatch. Class instances with methods are cloned as plain objects.\n *\n * Related functions:\n *\n * - {@link clone} — No validation\n * - {@link assertClone} — Throws instead of returning `null`\n * - {@link validateClone} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Value to clone\n * @returns Deep cloned value, or `null` if invalid\n */\nexport function isClone<T>(input: T): Resolved<T> | null;\n\n/** @internal */\nexport function isClone<T>(input: unknown): Resolved<T> | null;\n\n/** @internal */\nexport function isClone(): never {\n  NoTransformConfigurationError(\"plain.isClone\");\n}\n\n/**\n * Deep clones value with validation.\n *\n * Creates a deep copy with {@link validate} validation. Returns\n * {@link IValidation.IFailure} with all errors on mismatch, or\n * {@link IValidation.ISuccess} with cloned value. Class instances with methods\n * are cloned as plain objects.\n *\n * Related functions:\n *\n * - {@link clone} — No validation\n * - {@link assertClone} — Throws on first error\n * - {@link isClone} — Returns `null` instead of error details\n *\n * @template T Type of input value\n * @param input Value to clone\n * @returns Validation result containing cloned value or errors\n */\nexport function validateClone<T>(input: T): IValidation<Resolved<T>>;\n\n/** @internal */\nexport function validateClone<T>(input: unknown): IValidation<Resolved<T>>;\n\n/** @internal */\nexport function validateClone(): never {\n  NoTransformConfigurationError(\"plain.validateClone\");\n}\n\n/* -----------------------------------------------------------\n    PRUNE\n----------------------------------------------------------- */\n/**\n * Removes superfluous properties from object.\n *\n * Deletes all properties not defined in type `T`, including in nested objects.\n * Mutates the input directly—removed properties cannot be recovered.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertPrune} — Throws on type mismatch\n * - {@link isPrune} — Returns `false` on type mismatch\n * - {@link validatePrune} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to prune\n */\nexport function prune<T extends object>(input: T): void;\n\n/** @internal */\nexport function prune(): never {\n  NoTransformConfigurationError(\"plain.prune\");\n}\n\n/**\n * Removes superfluous properties with assertion.\n *\n * Combines {@link assert} with {@link prune}. Throws {@link TypeGuardError} on\n * type mismatch. Mutates the input directly—removed properties cannot be\n * recovered.\n *\n * Related functions:\n *\n * - {@link prune} — No validation\n * - {@link isPrune} — Returns `false` instead of throwing\n * - {@link validatePrune} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to assert and prune\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns The pruned input\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertPrune<T>(\n  input: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertPrune<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertPrune(): unknown {\n  NoTransformConfigurationError(\"plain.assertPrune\");\n}\n\n/**\n * Removes superfluous properties with type checking.\n *\n * Combines {@link is} with {@link prune}. Returns `false` on type mismatch (no\n * pruning occurs). Returns `true` after successful pruning. Mutates the input\n * directly.\n *\n * Related functions:\n *\n * - {@link prune} — No validation\n * - {@link assertPrune} — Throws instead of returning `false`\n * - {@link validatePrune} — Returns detailed validation errors\n *\n * @template T Type of input value\n * @param input Object to check and prune\n * @returns `true` if valid and pruned, `false` if type mismatch\n */\nexport function isPrune<T>(input: T): input is T;\n\n/** @internal */\nexport function isPrune<T>(input: unknown): input is T;\n\n/** @internal */\nexport function isPrune(): never {\n  NoTransformConfigurationError(\"plain.isPrune\");\n}\n\n/**\n * Removes superfluous properties with validation.\n *\n * Combines {@link validate} with {@link prune}. Returns\n * {@link IValidation.IFailure} with all errors on mismatch (no pruning occurs),\n * or {@link IValidation.ISuccess} after successful pruning. Mutates the input\n * directly.\n *\n * Related functions:\n *\n * - {@link prune} — No validation\n * - {@link assertPrune} — Throws on first error\n * - {@link isPrune} — Returns `false` instead of error details\n *\n * @template T Type of input value\n * @param input Object to validate and prune\n * @returns Validation result\n */\nexport function validatePrune<T>(input: T): IValidation<T>;\n\n/** @internal */\nexport function validatePrune<T>(input: unknown): IValidation<T>;\n\n/** @internal */\nexport function validatePrune<T>(): IValidation<T> {\n  NoTransformConfigurationError(\"plain.validatePrune\");\n}\n\n/* -----------------------------------------------------------\n    CLASSIFY\n----------------------------------------------------------- */\n/**\n * Reconstructs a class instance from plain data.\n *\n * Builds a real instance of class type `T` from a plain object, driven by\n * typia's compile-time type information — no decorators required (unlike\n * `class-transformer`). Each class is constructed by exactly one strategy, in\n * precedence order: a static factory `T.from(x)`, then `new T(x)` (single\n * argument), then field copy onto the prototype. Nested classes and containers\n * are reconstructed recursively, and methods come from the prototype.\n *\n * Does not validate the input. For validation, use:\n *\n * - {@link assertClassify} — Throws on type mismatch\n * - {@link validateClassify} — Returns detailed validation errors\n *\n * @template T Target class type to reconstruct\n * @param input Plain data to classify\n * @returns A real instance of type `T`\n */\nexport function classify<T>(input: Classifiable<T>): ClassifyResult<T>;\n\n/** @internal */\nexport function classify(): never {\n  NoTransformConfigurationError(\"plain.classify\");\n}\n\n/**\n * Reconstructs a class instance with assertion.\n *\n * Combines {@link assert} with {@link classify}: validates the plain input\n * against type `T`, throwing {@link TypeGuardError} on mismatch, then builds a\n * real instance of `T`.\n *\n * Related functions:\n *\n * - {@link classify} — No validation\n * - {@link validateClassify} — Returns detailed validation errors\n *\n * @template T Target class type to reconstruct\n * @param input Plain data to validate and classify\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns A real instance of type `T`\n * @throws {TypeGuardError} When input doesn't conform to type `T`\n */\nexport function assertClassify<T>(\n  input: Classifiable<T>,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): ClassifyResult<T>;\n\n/** @internal */\nexport function assertClassify<T>(\n  input: unknown,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): ClassifyResult<T>;\n\n/** @internal */\nexport function assertClassify(): never {\n  NoTransformConfigurationError(\"plain.assertClassify\");\n}\n\n/**\n * Reconstructs a class instance with validation.\n *\n * Combines {@link validate} with {@link classify}: validates the plain input\n * against type `T`, returning {@link IValidation.IFailure} with all errors on\n * mismatch, or {@link IValidation.ISuccess} holding a real instance of `T`.\n *\n * Related functions:\n *\n * - {@link classify} — No validation\n * - {@link assertClassify} — Throws on first error\n *\n * @template T Target class type to reconstruct\n * @param input Plain data to validate and classify\n * @returns Validation result containing the instance or errors\n */\nexport function validateClassify<T>(\n  input: Classifiable<T>,\n): IValidation<ClassifyResult<T>>;\n\n/** @internal */\nexport function validateClassify<T>(\n  input: unknown,\n): IValidation<ClassifyResult<T>>;\n\n/** @internal */\nexport function validateClassify(): never {\n  NoTransformConfigurationError(\"plain.validateClassify\");\n}\n\n/* -----------------------------------------------------------\n    FACTORY FUNCTIONS\n----------------------------------------------------------- */\n/**\n * Creates reusable {@link clone} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createClone(): never;\n\n/**\n * Creates reusable {@link clone} function.\n *\n * @template T Type of input value\n * @returns Reusable clone function\n */\nexport function createClone<T>(): (input: T) => Resolved<T>;\n\n/** @internal */\nexport function createClone(): never {\n  NoTransformConfigurationError(\"plain.createClone\");\n}\n\n/**\n * Creates reusable {@link assertClone} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertClone(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertClone} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable clone function\n */\nexport function createAssertClone<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => Resolved<T>;\n\n/** @internal */\nexport function createAssertClone(): never {\n  NoTransformConfigurationError(\"plain.createAssertClone\");\n}\n\n/**\n * Creates reusable {@link isClone} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsClone(): never;\n\n/**\n * Creates reusable {@link isClone} function.\n *\n * @template T Type of input value\n * @returns Reusable clone function\n */\nexport function createIsClone<T>(): (input: unknown) => Resolved<T> | null;\n\n/** @internal */\nexport function createIsClone(): never {\n  NoTransformConfigurationError(\"plain.createIsClone\");\n}\n\n/**\n * Creates reusable {@link validateClone} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateClone(): never;\n\n/**\n * Creates reusable {@link validateClone} function.\n *\n * @template T Type of input value\n * @returns Reusable clone function\n */\nexport function createValidateClone<T>(): (\n  input: unknown,\n) => IValidation<Resolved<T>>;\n\n/** @internal */\nexport function createValidateClone(): never {\n  NoTransformConfigurationError(\"plain.createValidateClone\");\n}\n\n/**\n * Creates reusable {@link prune} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createPrune(): never;\n\n/**\n * Creates reusable {@link prune} function.\n *\n * @template T Type of input value\n * @returns Reusable prune function\n */\nexport function createPrune<T extends object>(): (input: T) => void;\n\n/** @internal */\nexport function createPrune(): never {\n  NoTransformConfigurationError(\"plain.createPrune\");\n}\n\n/**\n * Creates reusable {@link assertPrune} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertPrune(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertPrune} function.\n *\n * @template T Type of input value\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable prune function\n */\nexport function createAssertPrune<T extends object>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => T;\n\n/** @internal */\nexport function createAssertPrune(): never {\n  NoTransformConfigurationError(\"plain.createAssertPrune\");\n}\n\n/**\n * Creates reusable {@link isPrune} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createIsPrune(): never;\n\n/**\n * Creates reusable {@link isPrune} function.\n *\n * @template T Type of input value\n * @returns Reusable prune function\n */\nexport function createIsPrune<T extends object>(): (\n  input: unknown,\n) => input is T;\n\n/** @internal */\nexport function createIsPrune(): never {\n  NoTransformConfigurationError(\"plain.createIsPrune\");\n}\n\n/**\n * Creates reusable {@link validatePrune} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidatePrune(): never;\n\n/**\n * Creates reusable {@link validatePrune} function.\n *\n * @template T Type of input value\n * @returns Reusable prune function\n */\nexport function createValidatePrune<T extends object>(): (\n  input: unknown,\n) => IValidation<T>;\n\n/** @internal */\nexport function createValidatePrune(): never {\n  NoTransformConfigurationError(\"plain.createValidatePrune\");\n}\n\n/**\n * Creates reusable {@link classify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createClassify(): never;\n\n/**\n * Creates reusable {@link classify} function.\n *\n * @template T Target class type to reconstruct\n * @returns Reusable classify function\n */\nexport function createClassify<T>(): (\n  input: Classifiable<T>,\n) => ClassifyResult<T>;\n\n/** @internal */\nexport function createClassify(): never {\n  NoTransformConfigurationError(\"plain.createClassify\");\n}\n\n/**\n * Creates reusable {@link assertClassify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createAssertClassify(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): never;\n\n/**\n * Creates reusable {@link assertClassify} function.\n *\n * @template T Target class type to reconstruct\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Reusable classify function\n */\nexport function createAssertClassify<T>(\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): (input: unknown) => ClassifyResult<T>;\n\n/** @internal */\nexport function createAssertClassify(): never {\n  NoTransformConfigurationError(\"plain.createAssertClassify\");\n}\n\n/**\n * Creates reusable {@link validateClassify} function.\n *\n * @danger You must configure the generic argument `T`\n */\nexport function createValidateClassify(): never;\n\n/**\n * Creates reusable {@link validateClassify} function.\n *\n * @template T Target class type to reconstruct\n * @returns Reusable classify function\n */\nexport function createValidateClassify<T>(): (\n  input: unknown,\n) => IValidation<ClassifyResult<T>>;\n\n/** @internal */\nexport function createValidateClassify(): never {\n  NoTransformConfigurationError(\"plain.createValidateClassify\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,QAAe;CAC7B,8BAA8B,aAAa;AAC7C;;AAkCA,SAAgB,cAAqB;CACnC,8BAA8B,mBAAmB;AACnD;;AAwBA,SAAgB,UAAiB;CAC/B,8BAA8B,eAAe;AAC/C;;AA0BA,SAAgB,gBAAuB;CACrC,8BAA8B,qBAAqB;AACrD;;AAuBA,SAAgB,QAAe;CAC7B,8BAA8B,aAAa;AAC7C;;AAkCA,SAAgB,cAAuB;CACrC,8BAA8B,mBAAmB;AACnD;;AAyBA,SAAgB,UAAiB;CAC/B,8BAA8B,eAAe;AAC/C;;AA0BA,SAAgB,gBAAmC;CACjD,8BAA8B,qBAAqB;AACrD;;AA2BA,SAAgB,WAAkB;CAChC,8BAA8B,gBAAgB;AAChD;;AAiCA,SAAgB,iBAAwB;CACtC,8BAA8B,sBAAsB;AACtD;;AA4BA,SAAgB,mBAA0B;CACxC,8BAA8B,wBAAwB;AACxD;;AAqBA,SAAgB,cAAqB;CACnC,8BAA8B,mBAAmB;AACnD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,yBAAyB;AACzD;;AAkBA,SAAgB,gBAAuB;CACrC,8BAA8B,qBAAqB;AACrD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,2BAA2B;AAC3D;;AAkBA,SAAgB,cAAqB;CACnC,8BAA8B,mBAAmB;AACnD;;AAwBA,SAAgB,oBAA2B;CACzC,8BAA8B,yBAAyB;AACzD;;AAoBA,SAAgB,gBAAuB;CACrC,8BAA8B,qBAAqB;AACrD;;AAoBA,SAAgB,sBAA6B;CAC3C,8BAA8B,2BAA2B;AAC3D;;AAoBA,SAAgB,iBAAwB;CACtC,8BAA8B,sBAAsB;AACtD;;AAwBA,SAAgB,uBAA8B;CAC5C,8BAA8B,4BAA4B;AAC5D;;AAoBA,SAAgB,yBAAgC;CAC9C,8BAA8B,8BAA8B;AAC9D"}

package/lib/protobuf.mjs

@@ -1,3 +1,94 @@
-export { assertDecode, assertEncode, createAssertDecode, createAssertEncode, createDecode, createEncode, createIsDecode, createIsEncode, createValidateDecode, createValidateEncode, decode, encode, isDecode, isEncode, message, validateDecode, validateEncode } from './protobuf2.mjs';
-export { __exports as default } from './_virtual/protobuf.mjs';
-//# sourceMappingURL=protobuf.mjs.map
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/protobuf.ts
+var protobuf_exports = /* @__PURE__ */ __exportAll({
+	assertDecode: () => assertDecode,
+	assertEncode: () => assertEncode,
+	createAssertDecode: () => createAssertDecode,
+	createAssertEncode: () => createAssertEncode,
+	createDecode: () => createDecode,
+	createEncode: () => createEncode,
+	createIsDecode: () => createIsDecode,
+	createIsEncode: () => createIsEncode,
+	createValidateDecode: () => createValidateDecode,
+	createValidateEncode: () => createValidateEncode,
+	decode: () => decode,
+	encode: () => encode,
+	isDecode: () => isDecode,
+	isEncode: () => isEncode,
+	message: () => message,
+	validateDecode: () => validateDecode,
+	validateEncode: () => validateEncode
+});
+/** @internal */
+function message() {
+	NoTransformConfigurationError("protobuf.message");
+}
+/** @internal */
+function decode() {
+	NoTransformConfigurationError("protobuf.decode");
+}
+/** @internal */
+function assertDecode() {
+	NoTransformConfigurationError("protobuf.assertDecode");
+}
+/** @internal */
+function isDecode() {
+	NoTransformConfigurationError("protobuf.isDecode");
+}
+/** @internal */
+function validateDecode() {
+	NoTransformConfigurationError("protobuf.validateDecode");
+}
+/** @internal */
+function encode() {
+	NoTransformConfigurationError("protobuf.encode");
+}
+/** @internal */
+function assertEncode() {
+	NoTransformConfigurationError("protobuf.assertEncode");
+}
+/** @internal */
+function isEncode() {
+	NoTransformConfigurationError("protobuf.isEncode");
+}
+/** @internal */
+function validateEncode() {
+	NoTransformConfigurationError("protobuf.validateEncode");
+}
+/** @internal */
+function createDecode() {
+	NoTransformConfigurationError("protobuf.createDecode");
+}
+/** @internal */
+function createIsDecode() {
+	NoTransformConfigurationError("protobuf.createIsDecode");
+}
+/** @internal */
+function createAssertDecode() {
+	NoTransformConfigurationError("protobuf.createAssertDecode");
+}
+/** @internal */
+function createValidateDecode() {
+	NoTransformConfigurationError("protobuf.createValidateDecode");
+}
+/** @internal */
+function createEncode() {
+	NoTransformConfigurationError("protobuf.createEncode");
+}
+/** @internal */
+function createIsEncode() {
+	NoTransformConfigurationError("protobuf.createIsEncode");
+}
+/** @internal */
+function createAssertEncode() {
+	NoTransformConfigurationError("protobuf.createAssertEncode");
+}
+/** @internal */
+function createValidateEncode() {
+	NoTransformConfigurationError("protobuf.createValidateEncode");
+}
+//#endregion
+export { assertDecode, assertEncode, createAssertDecode, createAssertEncode, createDecode, createEncode, createIsDecode, createIsEncode, createValidateDecode, createValidateEncode, decode, encode, isDecode, isEncode, message, protobuf_exports, validateDecode, validateEncode };
+
+//# sourceMappingURL=protobuf.mjs.map

package/lib/protobuf.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"protobuf.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"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): (input: Uint8Array) => Resolved<T>;\n\n/** @internal */\nexport function createAssertDecode<T>(): (input: Uint8Array) => 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): (input: T) => Uint8Array;\n\n/** @internal */\nexport function createAssertEncode<T>(): (input: T) => 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;;AAwBA,SAAgB,qBAA4D;CAC1E,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;;AAwBA,SAAgB,qBAAkD;CAChE,8BAA8B,6BAA6B;AAC7D;;AAoBA,SAAgB,uBAEa;CAC3B,8BAA8B,+BAA+B;AAC/D"}

package/lib/re-exports.d.ts

@@ -1 +1,2 @@
-export { AssertionGuard, IJsonParseResult, IValidation, IRandomGenerator, OpenApi, IJsonSchemaCollection, IJsonSchemaUnit, ILlmController, ILlmApplication, ILlmFunction, ILlmStructuredOutput, ILlmSchema, IMetadataSchema, IMetadataSchemaCollection, IMetadataSchemaUnit, IMetadataComponents, IMetadataTypeTag, IJsDocTagInfo, Classifiable, ClassifyResult, Primitive, Resolved, CamelCase, KebabCase, PascalCase, SnakeCase, IReadableURLSearchParams, tags, } from "@typia/interface";
+export type { AssertionGuard, IJsonParseResult, IValidation, IRandomGenerator, OpenApi, IJsonSchemaCollection, IJsonSchemaUnit, ILlmController, ILlmApplication, ILlmFunction, ILlmStructuredOutput, ILlmSchema, IMetadataSchema, IMetadataSchemaCollection, IMetadataSchemaUnit, IMetadataComponents, IMetadataTypeTag, IJsDocTagInfo, Classifiable, ClassifyResult, Primitive, Resolved, CamelCase, KebabCase, PascalCase, SnakeCase, IReadableURLSearchParams, } from "@typia/interface";
+export { tags } from "@typia/interface";

package/lib/re-exports.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tags = void 0;
+// `tags` is the only runtime value `@typia/interface` exports. Everything
+// above must stay `export type`: the `.mjs` build transpiles per file
+// (rolldown/oxc, no cross-file type info), so a plain re-export of a type
+// would survive as a runtime import and crash against the CJS-only
+// `@typia/interface`.
 var interface_1 = require("@typia/interface");
-// namespaces
 Object.defineProperty(exports, "tags", { enumerable: true, get: function () { return interface_1.tags; } });
 //# sourceMappingURL=re-exports.js.map

package/lib/re-exports.js.map

@@ -1 +1 @@
-{"version":3,"file":"re-exports.js","sourceRoot":"","sources":["../src/re-exports.ts"],"names":[],"mappings":";;;AAAA,8CAoC0B;AAFxB,aAAa;AACb,iGAAA,IAAI,OAAA"}
+{"version":3,"file":"re-exports.js","sourceRoot":"","sources":["../src/re-exports.ts"],"names":[],"mappings":";;;AAoCA,0EAA0E;AAC1E,sEAAsE;AACtE,0EAA0E;AAC1E,mEAAmE;AACnE,sBAAsB;AACtB,8CAAwC;AAA/B,iGAAA,IAAI,OAAA"}

package/lib/re-exports.mjs

@@ -1,2 +1,2 @@
-export { default } from './re-exports2.mjs';
-//# sourceMappingURL=re-exports.mjs.map
+import { tags } from "@typia/interface";
+export { tags };

package/lib/reflect.mjs

@@ -1,3 +1,29 @@
-export { literals, name, schema, schemas } from './reflect2.mjs';
-export { __exports as default } from './_virtual/reflect.mjs';
-//# sourceMappingURL=reflect.mjs.map
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/reflect.ts
+var reflect_exports = /* @__PURE__ */ __exportAll({
+	literals: () => literals,
+	name: () => name,
+	schema: () => schema,
+	schemas: () => schemas
+});
+/** @internal */
+function schemas() {
+	NoTransformConfigurationError("reflect.schemas");
+}
+/** @internal */
+function schema() {
+	NoTransformConfigurationError("reflect.schema");
+}
+/** @internal */
+function name() {
+	NoTransformConfigurationError("reflect.name");
+}
+/** @internal */
+function literals() {
+	NoTransformConfigurationError("reflect.literals");
+}
+//#endregion
+export { literals, name, reflect_exports, schema, schemas };
+
+//# sourceMappingURL=reflect.mjs.map

package/lib/reflect.mjs.map

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

package/lib/transform.mjs

@@ -1,2 +1,15 @@
-export { createTtscPlugin, default } from './transform2.mjs';
-//# sourceMappingURL=transform.mjs.map
+import path from "node:path";
+import { createRequire } from "node:module";
+//#region src/transform.ts
+function createTtscPlugin(context) {
+	const requireFrom = createRequire(path.join(context.projectRoot, "package.json"));
+	const root = path.dirname(requireFrom.resolve("typia/package.json"));
+	return {
+		name: "typia",
+		source: path.resolve(root, "native", "cmd", "ttsc-typia")
+	};
+}
+//#endregion
+export { createTtscPlugin, createTtscPlugin as default };
+
+//# sourceMappingURL=transform.mjs.map