typia 13.0.1-dev.20260703.1 → 13.0.2

package/lib/internal/_validateReport.mjs

@@ -1,3 +1,23 @@
-export { _validateReport } from './_validateReport2.mjs';
-export { __exports as default } from '../_virtual/_validateReport.mjs';
-//# sourceMappingURL=_validateReport.mjs.map
+//#region src/internal/_validateReport.ts
+const _validateReport = (array) => {
+	const reportable = (path) => {
+		if (array.length === 0) return true;
+		const last = array[array.length - 1].path;
+		return path.length > last.length || last.substring(0, path.length) !== path;
+	};
+	return (exceptable, error) => {
+		if (exceptable && reportable(error.path)) {
+			if (error.value === void 0) error.description ??= [
+				"The value at this path is `undefined`.",
+				"",
+				`Please fill the \`${error.expected}\` typed value next time.`
+			].join("\n");
+			array.push(error);
+		}
+		return false;
+	};
+};
+//#endregion
+export { _validateReport };
+
+//# sourceMappingURL=_validateReport.mjs.map

package/lib/internal/_validateReport.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_validateReport.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"_validateReport.mjs","names":[],"sources":["../../src/internal/_validateReport.ts"],"sourcesContent":["import { IValidation } from \"@typia/interface\";\n\nexport const _validateReport = (array: IValidation.IError[]) => {\n  const reportable = (path: string): boolean => {\n    if (array.length === 0) return true;\n    const last: string = array[array.length - 1]!.path;\n    return path.length > last.length || last.substring(0, path.length) !== path;\n  };\n  return (exceptable: boolean, error: IValidation.IError): false => {\n    if (exceptable && reportable(error.path)) {\n      if (error.value === undefined)\n        error.description ??= [\n          \"The value at this path is `undefined`.\",\n          \"\",\n          `Please fill the \\`${error.expected}\\` typed value next time.`,\n        ].join(\"\\n\");\n      array.push(error);\n    }\n    return false;\n  };\n};\n"],"mappings":";AAEA,MAAa,mBAAmB,UAAgC;CAC9D,MAAM,cAAc,SAA0B;EAC5C,IAAI,MAAM,WAAW,GAAG,OAAO;EAC/B,MAAM,OAAe,MAAM,MAAM,SAAS,EAAE,CAAE;EAC9C,OAAO,KAAK,SAAS,KAAK,UAAU,KAAK,UAAU,GAAG,KAAK,MAAM,MAAM;CACzE;CACA,QAAQ,YAAqB,UAAqC;EAChE,IAAI,cAAc,WAAW,MAAM,IAAI,GAAG;GACxC,IAAI,MAAM,UAAU,KAAA,GAClB,MAAM,gBAAgB;IACpB;IACA;IACA,qBAAqB,MAAM,SAAS;GACtC,CAAC,CAAC,KAAK,IAAI;GACb,MAAM,KAAK,KAAK;EAClB;EACA,OAAO;CACT;AACF"}

package/lib/internal/private/__notationCapitalize.mjs

@@ -1,3 +1,6 @@
-export { __notationCapitalize } from './__notationCapitalize2.mjs';
-export { __exports as default } from '../../_virtual/__notationCapitalize.mjs';
-//# sourceMappingURL=__notationCapitalize.mjs.map
+//#region src/internal/private/__notationCapitalize.ts
+const __notationCapitalize = (str) => str.length ? str[0].toUpperCase() + str.slice(1).toLowerCase() : str;
+//#endregion
+export { __notationCapitalize };
+
+//# sourceMappingURL=__notationCapitalize.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"__notationCapitalize.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"__notationCapitalize.mjs","names":[],"sources":["../../../src/internal/private/__notationCapitalize.ts"],"sourcesContent":["export const __notationCapitalize = (str: string) =>\n  str.length ? str[0]!.toUpperCase() + str.slice(1).toLowerCase() : str;\n"],"mappings":";AAAA,MAAa,wBAAwB,QACnC,IAAI,SAAS,IAAI,EAAE,CAAE,YAAY,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC,YAAY,IAAI"}

package/lib/internal/private/__notationUnsnake.mjs

@@ -1,3 +1,15 @@
-export { __notationUnsnake } from './__notationUnsnake2.mjs';
-export { __exports as default } from '../../_virtual/__notationUnsnake.mjs';
-//# sourceMappingURL=__notationUnsnake.mjs.map
+//#region src/internal/private/__notationUnsnake.ts
+const __notationUnsnake = (props) => (str) => {
+	let prefix = "";
+	for (let i = 0; i < str.length; i++) if (str[i] === "_") prefix += "_";
+	else break;
+	if (prefix.length !== 0) str = str.substring(prefix.length);
+	const out = (s) => `${prefix}${s}`;
+	if (str.length === 0) return out("");
+	const items = str.split("_").filter((s) => s.length !== 0);
+	return items.length === 0 ? out("") : items.length === 1 ? out(props.plain(items[0])) : out(items.map(props.snake).join(""));
+};
+//#endregion
+export { __notationUnsnake };
+
+//# sourceMappingURL=__notationUnsnake.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"__notationUnsnake.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"__notationUnsnake.mjs","names":[],"sources":["../../../src/internal/private/__notationUnsnake.ts"],"sourcesContent":["export const __notationUnsnake =\n  (props: {\n    plain: (str: string) => string;\n    snake: (str: string, index: number) => string;\n  }) =>\n  (str: string): string => {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    let prefix: string = \"\";\n    for (let i: number = 0; i < str.length; i++) {\n      if (str[i] === \"_\") prefix += \"_\";\n      else break;\n    }\n    if (prefix.length !== 0) str = str.substring(prefix.length);\n\n    const out = (s: string) => `${prefix}${s}`;\n    if (str.length === 0) return out(\"\");\n\n    const items: string[] = str.split(\"_\").filter((s) => s.length !== 0);\n    return items.length === 0\n      ? out(\"\")\n      : items.length === 1\n        ? out(props.plain(items[0]!))\n        : out(items.map(props.snake).join(\"\"));\n  };\n"],"mappings":";AAAA,MAAa,qBACV,WAIA,QAAwB;CAEvB,IAAI,SAAiB;CACrB,KAAK,IAAI,IAAY,GAAG,IAAI,IAAI,QAAQ,KACtC,IAAI,IAAI,OAAO,KAAK,UAAU;MACzB;CAEP,IAAI,OAAO,WAAW,GAAG,MAAM,IAAI,UAAU,OAAO,MAAM;CAE1D,MAAM,OAAO,MAAc,GAAG,SAAS;CACvC,IAAI,IAAI,WAAW,GAAG,OAAO,IAAI,EAAE;CAEnC,MAAM,QAAkB,IAAI,MAAM,GAAG,CAAC,CAAC,QAAQ,MAAM,EAAE,WAAW,CAAC;CACnE,OAAO,MAAM,WAAW,IACpB,IAAI,EAAE,IACN,MAAM,WAAW,IACf,IAAI,MAAM,MAAM,MAAM,EAAG,CAAC,IAC1B,IAAI,MAAM,IAAI,MAAM,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC;AAC3C"}

package/lib/json.mjs

@@ -1,3 +1,94 @@
-export { application, assertParse, assertStringify, createAssertParse, createAssertStringify, createIsParse, createIsStringify, createStringify, createValidateParse, createValidateStringify, isParse, isStringify, schema, schemas, stringify, validateParse, validateStringify } from './json2.mjs';
-export { __exports as default } from './_virtual/json.mjs';
-//# sourceMappingURL=json.mjs.map
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError.mjs";
+//#region src/json.ts
+var json_exports = /* @__PURE__ */ __exportAll({
+	application: () => application,
+	assertParse: () => assertParse,
+	assertStringify: () => assertStringify,
+	createAssertParse: () => createAssertParse,
+	createAssertStringify: () => createAssertStringify,
+	createIsParse: () => createIsParse,
+	createIsStringify: () => createIsStringify,
+	createStringify: () => createStringify,
+	createValidateParse: () => createValidateParse,
+	createValidateStringify: () => createValidateStringify,
+	isParse: () => isParse,
+	isStringify: () => isStringify,
+	schema: () => schema,
+	schemas: () => schemas,
+	stringify: () => stringify,
+	validateParse: () => validateParse,
+	validateStringify: () => validateStringify
+});
+/** @internal */
+function schema() {
+	NoTransformConfigurationError("json.schema");
+}
+/** @internal */
+function schemas() {
+	NoTransformConfigurationError("json.schemas");
+}
+/** @internal */
+function application() {
+	NoTransformConfigurationError("json.application");
+}
+/** @internal */
+function assertParse() {
+	NoTransformConfigurationError("json.assertParse");
+}
+/** @internal */
+function isParse() {
+	NoTransformConfigurationError("json.isParse");
+}
+/** @internal */
+function validateParse() {
+	NoTransformConfigurationError("json.validateParse");
+}
+/** @internal */
+function stringify() {
+	NoTransformConfigurationError("json.stringify");
+}
+/** @internal */
+function assertStringify() {
+	NoTransformConfigurationError("json.assertStringify");
+}
+/** @internal */
+function isStringify() {
+	NoTransformConfigurationError("json.isStringify");
+}
+/** @internal */
+function validateStringify() {
+	NoTransformConfigurationError("json.validateStringify");
+}
+/** @internal */
+function createIsParse() {
+	NoTransformConfigurationError("json.createIsParse");
+}
+/** @internal */
+function createAssertParse() {
+	NoTransformConfigurationError("json.createAssertParse");
+}
+/** @internal */
+function createValidateParse() {
+	NoTransformConfigurationError("json.createValidateParse");
+}
+/** @internal */
+function createStringify() {
+	NoTransformConfigurationError("json.createStringify");
+}
+/** @internal */
+function createAssertStringify() {
+	NoTransformConfigurationError("json.createAssertStringify");
+}
+/** @internal */
+function createIsStringify() {
+	NoTransformConfigurationError("json.createIsStringify");
+}
+/** @internal */
+function createValidateStringify() {
+	NoTransformConfigurationError("json.createValidateStringify");
+}
+//#endregion
+export { application, assertParse, assertStringify, createAssertParse, createAssertStringify, createIsParse, createIsStringify, createStringify, createValidateParse, createValidateStringify, isParse, isStringify, json_exports, schema, schemas, stringify, validateParse, validateStringify };
+
+//# sourceMappingURL=json.mjs.map

package/lib/json.mjs.map

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

package/lib/llm.mjs

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

package/lib/llm.mjs.map

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

package/lib/module.mjs

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

package/lib/module.mjs.map

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