@autobe/compiler 0.28.0 → 0.28.1

package/src/raw/test.json

@@ -8,7 +8,7 @@
   "node_modules/@nestia/e2e/lib/index.d.ts": "import * as e2e from \"./module\";\nexport default e2e;\nexport * from \"./module\";\n",
   "node_modules/@nestia/e2e/lib/internal/json_equal_to.d.ts": "export declare const json_equal_to: (exception: (key: string) => boolean) => <T>(x: T) => (y: T | null | undefined) => string[];\n",
   "node_modules/@nestia/e2e/lib/module.d.ts": "export * from \"./ArrayUtil\";\nexport * from \"./MapUtil\";\nexport * from \"./RandomGenerator\";\nexport * from \"./DynamicExecutor\";\nexport * from \"./GaffComparator\";\nexport * from \"./TestValidator\";\n",
-  "node_modules/@nestia/e2e/package.json": "{\n  \"name\": \"@nestia/e2e\",\n  \"version\": \"9.0.0\",\n  \"description\": \"E2E test utilify functions\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"scripts\": {\n    \"build\": \"npm run build:main && npm run build:test\",\n    \"build:main\": \"rimraf lib && tsc\",\n    \"build:test\": \"rimraf bin && tsc -p test/tsconfig.json\",\n    \"dev\": \"npm run build:test -- --watch\",\n    \"eslint\": \"eslint src && eslint test\",\n    \"prepare\": \"ts-patch install && typia patch\",\n    \"test\": \"node bin/test\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia\"\n  },\n  \"keywords\": [\n    \"e2e\",\n    \"nestia\",\n    \"nestjs\",\n    \"test\",\n    \"tdd\",\n    \"utility\"\n  ],\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia/issues\"\n  },\n  \"homepage\": \"https://nestia.io\",\n  \"devDependencies\": {\n    \"@trivago/prettier-plugin-sort-imports\": \"^4.0.0\",\n    \"@types/node\": \"^18.11.18\",\n    \"@typescript-eslint/eslint-plugin\": \"^5.57.0\",\n    \"@typescript-eslint/parser\": \"^5.57.0\",\n    \"rimraf\": \"^6.0.1\",\n    \"ts-node\": \"^10.9.1\",\n    \"ts-patch\": \"^3.3.0\",\n    \"typescript\": \"~5.9.3\",\n    \"typescript-transform-paths\": \"^3.4.7\",\n    \"typia\": \"^10.0.0\"\n  },\n  \"files\": [\n    \"lib\",\n    \"src\",\n    \"README.md\",\n    \"LICENSE\",\n    \"package.json\"\n  ]\n}",
+  "node_modules/@nestia/e2e/package.json": "{\n  \"name\": \"@nestia/e2e\",\n  \"version\": \"9.0.1\",\n  \"description\": \"E2E test utilify functions\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"scripts\": {\n    \"build\": \"npm run build:main && npm run build:test\",\n    \"build:main\": \"rimraf lib && tsc\",\n    \"build:test\": \"rimraf bin && tsc -p test/tsconfig.json\",\n    \"dev\": \"npm run build:test -- --watch\",\n    \"eslint\": \"eslint src && eslint test\",\n    \"prepare\": \"ts-patch install && typia patch\",\n    \"test\": \"node bin/test\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia\"\n  },\n  \"keywords\": [\n    \"e2e\",\n    \"nestia\",\n    \"nestjs\",\n    \"test\",\n    \"tdd\",\n    \"utility\"\n  ],\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia/issues\"\n  },\n  \"homepage\": \"https://nestia.io\",\n  \"devDependencies\": {\n    \"@trivago/prettier-plugin-sort-imports\": \"^4.0.0\",\n    \"@types/node\": \"^18.11.18\",\n    \"@typescript-eslint/eslint-plugin\": \"^5.57.0\",\n    \"@typescript-eslint/parser\": \"^5.57.0\",\n    \"rimraf\": \"^6.0.1\",\n    \"ts-node\": \"^10.9.1\",\n    \"ts-patch\": \"^3.3.0\",\n    \"typescript\": \"~5.9.3\",\n    \"typescript-transform-paths\": \"^3.4.7\",\n    \"typia\": \"^10.0.0\"\n  },\n  \"files\": [\n    \"lib\",\n    \"src\",\n    \"README.md\",\n    \"LICENSE\",\n    \"package.json\"\n  ]\n}",
   "node_modules/@nestia/fetcher/lib/AesPkcs5.d.ts": "/**\n * Utility class for the AES-128/256 encryption.\n *\n * - AES-128/256\n * - CBC mode\n * - PKCS#5 Padding\n * - Base64 Encoding\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace AesPkcs5 {\n    /**\n     * Encrypt data\n     *\n     * @param data Target data\n     * @param key Key value of the encryption.\n     * @param iv Initializer Vector for the encryption\n     * @returns Encrypted data\n     */\n    function encrypt(data: string, key: string, iv: string): string;\n    /**\n     * Decrypt data.\n     *\n     * @param data Target data\n     * @param key Key value of the decryption.\n     * @param iv Initializer Vector for the decryption\n     * @returns Decrypted data.\n     */\n    function decrypt(data: string, key: string, iv: string): string;\n}\n",
   "node_modules/@nestia/fetcher/lib/EncryptedFetcher.d.ts": "import { IConnection } from \"./IConnection\";\nimport { IFetchRoute } from \"./IFetchRoute\";\nimport { IPropagation } from \"./IPropagation\";\n/**\n * Utility class for `fetch` functions used in `@nestia/sdk` with encryption.\n *\n * `EncryptedFetcher` is a utility class designed for SDK functions generated by\n * [`@nestia/sdk`](https://nestia.io/docs/sdk/sdk), interacting with the remote\n * HTTP API encrypted by AES-PKCS algorithm. In other words, this is a\n * collection of dedicated `fetch()` functions for `@nestia/sdk` with\n * encryption.\n *\n * For reference, `EncryptedFetcher` class being used only when target\n * controller method is encrypting body data by `@EncryptedRoute` or\n * `@EncryptedBody` decorators. If those decorators are not used,\n * {@link PlainFetcher} class would be used instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace EncryptedFetcher {\n    /**\n     * Fetch function only for `HEAD` method.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Nothing because of `HEAD` method\n     */\n    function fetch(connection: IConnection, route: IFetchRoute<\"HEAD\">): Promise<void>;\n    /**\n     * Fetch function only for `GET` method.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Response body data from the remote API\n     */\n    function fetch<Output>(connection: IConnection, route: IFetchRoute<\"GET\">): Promise<Output>;\n    /**\n     * Fetch function for the `POST`, `PUT`, `PATCH` and `DELETE` methods.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Response body data from the remote API\n     */\n    function fetch<Input, Output>(connection: IConnection, route: IFetchRoute<\"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;\n    function propagate<Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<\"GET\" | \"HEAD\">): Promise<Output>;\n    function propagate<Input, Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;\n}\n",
   "node_modules/@nestia/fetcher/lib/FormDataInput.d.ts": "/**\n * FormData input type.\n *\n * `FormDataInput<T>` is a type for the input of the `FormData` request, casting\n * `File` property value type as an union of `File` and\n * {@link FormDataInput.IFileProps}, especially for the React Native\n * environment.\n *\n * You know what? In the React Native environment, `File` class is not\n * supported. Therefore, when composing a `FormData` request, you have to put\n * the URI address of the local filesystem with file name and content type that\n * is represented by the {@link FormDataInput.IFileProps} type.\n *\n * This `FormDataInput<T>` type is designed for that purpose. If the property\n * value type is a `File` class, it converts it to an union type of `File` and\n * {@link FormDataInput.IFileProps} type. Also, if the property value type is an\n * array of `File` class, it converts it to an array of union type of `File` and\n * {@link FormDataInput.IFileProps} type too.\n *\n * Before | After ----------|------------------------ `boolean` | `boolean`\n * `bigint` | `bigint` `number` | `number` `string` | `string` `File` | `File \\|\n * IFileProps`\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target object type.\n */\nexport type FormDataInput<T extends object> = T extends Array<any> ? never : T extends Function ? never : {\n    [P in keyof T]: T[P] extends Array<infer U> ? FormDataInput.Value<U>[] : FormDataInput.Value<T[P]>;\n};\nexport declare namespace FormDataInput {\n    /**\n     * Value type of the `FormDataInput`.\n     *\n     * `Value<T>` is a type for the property value defined in the `FormDataInput`.\n     *\n     * If the original value type is a `File` class, `Value<T>` converts it to an\n     * union type of `File` and {@link IFileProps} type which is a structured data\n     * for the URI file location in the React Native environment.\n     */\n    type Value<T> = T extends File ? T | IFileProps : T;\n    /**\n     * Properties of a file.\n     *\n     * In the React Native, this `IFileProps` structured data can replace the\n     * `File` class instance in the `FormData` request.\n     *\n     * Just put the {@link uri URI address} of the local file system with the\n     * file's {@link name} and {@link type}. It would be casted to the `File` class\n     * instance automatically in the `FormData` request.\n     *\n     * Note that, this `IFileProps` type works only in the React Native\n     * environment. If you are developing a Web or NodeJS application, you have to\n     * utilize the `File` class instance directly.\n     */\n    interface IFileProps {\n        /**\n         * URI address of the file.\n         *\n         * In the React Native, the URI address in the local file system can replace\n         * the `File` class instance. If\n         *\n         * @format uri\n         */\n        uri: string;\n        /** Name of the file. */\n        name: string;\n        /** Content type of the file. */\n        type: string;\n    }\n}\n",
@@ -23,7 +23,7 @@
   "node_modules/@nestia/fetcher/lib/PlainFetcher.d.ts": "import { IConnection } from \"./IConnection\";\nimport { IFetchRoute } from \"./IFetchRoute\";\nimport { IPropagation } from \"./IPropagation\";\n/**\n * Utility class for `fetch` functions used in `@nestia/sdk`.\n *\n * `PlainFetcher` is a utility class designed for SDK functions generated by\n * [`@nestia/sdk`](https://nestia.io/docs/sdk/sdk), interacting with the remote\n * HTTP sever API. In other words, this is a collection of dedicated `fetch()`\n * functions for `@nestia/sdk`.\n *\n * For reference, `PlainFetcher` class does not encrypt or decrypt the body data\n * at all. It just delivers plain data without any post processing. If you've\n * defined a controller method through `@EncryptedRoute` or `@EncryptedBody`\n * decorator, then {@liink EncryptedFetcher} class would be used instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace PlainFetcher {\n    /**\n     * Fetch function only for `HEAD` method.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Nothing because of `HEAD` method\n     */\n    function fetch(connection: IConnection, route: IFetchRoute<\"HEAD\">): Promise<void>;\n    /**\n     * Fetch function only for `GET` method.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Response body data from the remote API\n     */\n    function fetch<Output>(connection: IConnection, route: IFetchRoute<\"GET\">): Promise<Output>;\n    /**\n     * Fetch function for the `POST`, `PUT`, `PATCH` and `DELETE` methods.\n     *\n     * @param connection Connection information for the remote HTTP server\n     * @param route Route information about the target API\n     * @returns Response body data from the remote API\n     */\n    function fetch<Input, Output>(connection: IConnection, route: IFetchRoute<\"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;\n    function propagate<Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<\"GET\" | \"HEAD\">): Promise<Output>;\n    function propagate<Input, Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;\n}\n",
   "node_modules/@nestia/fetcher/lib/index.d.ts": "export * from \"./FormDataInput\";\nexport * from \"./HttpError\";\nexport * from \"./IConnection\";\nexport * from \"./IEncryptionPassword\";\nexport * from \"./IFetchEvent\";\nexport * from \"./IFetchRoute\";\nexport * from \"./IPropagation\";\n",
   "node_modules/@nestia/fetcher/lib/internal/FetcherBase.d.ts": "export {};\n",
-  "node_modules/@nestia/fetcher/package.json": "{\n  \"name\": \"@nestia/fetcher\",\n  \"version\": \"9.0.0\",\n  \"description\": \"Fetcher library of Nestia SDK\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"scripts\": {\n    \"build\": \"rimraf lib && tsc\",\n    \"dev\": \"tsc -p tsconfig.test.json --watch\",\n    \"eslint\": \"eslint src\",\n    \"eslint:fix\": \"eslint src --fix\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia\"\n  },\n  \"keywords\": [\n    \"nestia\",\n    \"fetcher\",\n    \"sdk\"\n  ],\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia/issues\"\n  },\n  \"homepage\": \"https://nestia.io\",\n  \"dependencies\": {\n    \"@samchon/openapi\": \"^5.0.0\"\n  },\n  \"devDependencies\": {\n    \"@types/node\": \"^18.11.14\",\n    \"@typescript-eslint/eslint-plugin\": \"^5.46.1\",\n    \"@typescript-eslint/parser\": \"^5.46.1\",\n    \"rimraf\": \"^6.0.1\",\n    \"typescript\": \"~5.9.3\"\n  },\n  \"files\": [\n    \"README.md\",\n    \"LICENSE\",\n    \"package.json\",\n    \"lib\",\n    \"src\"\n  ]\n}",
+  "node_modules/@nestia/fetcher/package.json": "{\n  \"name\": \"@nestia/fetcher\",\n  \"version\": \"9.0.1\",\n  \"description\": \"Fetcher library of Nestia SDK\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"scripts\": {\n    \"build\": \"rimraf lib && tsc\",\n    \"dev\": \"tsc -p tsconfig.test.json --watch\",\n    \"eslint\": \"eslint src\",\n    \"eslint:fix\": \"eslint src --fix\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/nestia\"\n  },\n  \"keywords\": [\n    \"nestia\",\n    \"fetcher\",\n    \"sdk\"\n  ],\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/nestia/issues\"\n  },\n  \"homepage\": \"https://nestia.io\",\n  \"dependencies\": {\n    \"@samchon/openapi\": \"^5.0.0\"\n  },\n  \"devDependencies\": {\n    \"@types/node\": \"^18.11.14\",\n    \"@typescript-eslint/eslint-plugin\": \"^5.46.1\",\n    \"@typescript-eslint/parser\": \"^5.46.1\",\n    \"rimraf\": \"^6.0.1\",\n    \"typescript\": \"~5.9.3\"\n  },\n  \"files\": [\n    \"README.md\",\n    \"LICENSE\",\n    \"package.json\",\n    \"lib\",\n    \"src\"\n  ]\n}",
   "node_modules/@samchon/openapi/lib/HttpLlm.d.ts": "import { OpenApi } from \"./OpenApi\";\nimport { OpenApiV3 } from \"./OpenApiV3\";\nimport { OpenApiV3_1 } from \"./OpenApiV3_1\";\nimport { SwaggerV2 } from \"./SwaggerV2\";\nimport { IHttpConnection } from \"./structures/IHttpConnection\";\nimport { IHttpLlmApplication } from \"./structures/IHttpLlmApplication\";\nimport { IHttpLlmFunction } from \"./structures/IHttpLlmFunction\";\nimport { IHttpResponse } from \"./structures/IHttpResponse\";\nimport { ILlmFunction } from \"./structures/ILlmFunction\";\nimport { ILlmSchema } from \"./structures/ILlmSchema\";\n/**\n * LLM function calling application composer from OpenAPI document.\n *\n * `HttpLlm` is a module for composing LLM (Large Language Model) function\n * calling application from the {@link OpenApi.IDocument OpenAPI document}, and\n * also for LLM function call execution and parameter merging.\n *\n * At first, you can construct the LLM function calling application by the\n * {@link HttpLlm.application HttpLlm.application()} function. And then the LLM\n * has selected a {@link IHttpLlmFunction function} to call and composes its\n * arguments, you can execute the function by\n * {@link HttpLlm.execute HttpLlm.execute()} or\n * {@link HttpLlm.propagate HttpLlm.propagate()}.\n *\n * By the way, if you have configured the\n * {@link IHttpLlmApplication.IOptions.separate} option to separate the\n * parameters into human and LLM sides, you can merge these human and LLM sides'\n * parameters into one through\n * {@link HttpLlm.mergeParameters HttpLlm.mergeParameters()} before the actual\n * LLM function call execution.\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace HttpLlm {\n    /**\n     * Properties for the LLM function calling application composer.\n     *\n     * @template Model Target LLM model\n     */\n    interface IApplicationProps<Model extends ILlmSchema.Model> {\n        /** Target LLM model. */\n        model: Model;\n        /** OpenAPI document to convert. */\n        document: OpenApi.IDocument | SwaggerV2.IDocument | OpenApiV3.IDocument | OpenApiV3_1.IDocument;\n        /** Options for the LLM function calling schema conversion. */\n        options?: Partial<IHttpLlmApplication.IOptions<Model>>;\n    }\n    /**\n     * Convert OpenAPI document to LLM function calling application.\n     *\n     * Converts {@link OpenApi.IDocument OpenAPI document} or\n     * {@link IHttpMigrateApplication migrated application} to the\n     * {@link IHttpLlmApplication LLM function calling application}. Every\n     * {@link OpenApi.IOperation API operations} in the OpenAPI document are\n     * converted to the {@link IHttpLlmFunction LLM function} type, and they would\n     * be used for the LLM function calling.\n     *\n     * If you have configured the {@link IHttpLlmApplication.IOptions.separate}\n     * option, every parameters in the {@link IHttpLlmFunction} would be separated\n     * into both human and LLM sides. In that case, you can merge these human and\n     * LLM sides' parameters into one through {@link HttpLlm.mergeParameters}\n     * before the actual LLM function call execution.\n     *\n     * Additionally, if you have configured the\n     * {@link IHttpLlmApplication.IOptions.keyword} as `true`, the number of\n     * {@link IHttpLlmFunction.parameters} are always 1 and the first parameter\n     * type is always {@link ILlmSchemaV3.IObject}. I recommend this option because\n     * LLM can understand the keyword arguments more easily.\n     *\n     * @param props Properties for composition\n     * @returns LLM function calling application\n     */\n    const application: <Model extends ILlmSchema.Model>(props: IApplicationProps<Model>) => IHttpLlmApplication<Model>;\n    /** Properties for the LLM function call. */\n    interface IFetchProps<Model extends ILlmSchema.Model> {\n        /** Application of the LLM function calling. */\n        application: IHttpLlmApplication<Model>;\n        /** LLM function schema to call. */\n        function: IHttpLlmFunction<ILlmSchema.Model>;\n        /** Connection info to the HTTP server. */\n        connection: IHttpConnection;\n        /** Input arguments for the function call. */\n        input: object;\n    }\n    /**\n     * Execute the LLM function call.\n     *\n     * `HttmLlm.execute()` is a function executing the target\n     * {@link OpenApi.IOperation API endpoint} with with the connection information\n     * and arguments composed by Large Language Model like OpenAI (+human\n     * sometimes).\n     *\n     * By the way, if you've configured the\n     * {@link IHttpLlmApplication.IOptions.separate}, so that the parameters are\n     * separated to human and LLM sides, you have to merge these humand and LLM\n     * sides' parameters into one through {@link HttpLlm.mergeParameters}\n     * function.\n     *\n     * About the {@link IHttpLlmApplication.IOptions.keyword} option, don't worry\n     * anything. This `HttmLlm.execute()` function will automatically recognize\n     * the keyword arguments and convert them to the proper sequence.\n     *\n     * For reference, if the target API endpoinnt responds none 200/201 status,\n     * this would be considered as an error and the {@link HttpError} would be\n     * thrown. Otherwise you don't want such rule, you can use the\n     * {@link HttpLlm.propagate} function instead.\n     *\n     * @param props Properties for the LLM function call\n     * @returns Return value (response body) from the API endpoint\n     * @throws HttpError when the API endpoint responds none 200/201 status\n     */\n    const execute: <Model extends ILlmSchema.Model>(props: IFetchProps<Model>) => Promise<unknown>;\n    /**\n     * Propagate the LLM function call.\n     *\n     * `HttmLlm.propagate()` is a function propagating the target\n     * {@link OpenApi.IOperation API endpoint} with with the connection information\n     * and arguments composed by Large Language Model like OpenAI (+human\n     * sometimes).\n     *\n     * By the way, if you've configured the\n     * {@link IHttpLlmApplication.IOptions.separate}, so that the parameters are\n     * separated to human and LLM sides, you have to merge these humand and LLM\n     * sides' parameters into one through {@link HttpLlm.mergeParameters}\n     * function.\n     *\n     * About the {@link IHttpLlmApplication.IOptions.keyword} option, don't worry\n     * anything. This `HttmLlm.propagate()` function will automatically recognize\n     * the keyword arguments and convert them to the proper sequence.\n     *\n     * For reference, the propagation means always returning the response from the\n     * API endpoint, even if the status is not 200/201. This is useful when you\n     * want to handle the response by yourself.\n     *\n     * @param props Properties for the LLM function call\n     * @returns Response from the API endpoint\n     * @throws Error only when the connection is failed\n     */\n    const propagate: <Model extends ILlmSchema.Model>(props: IFetchProps<Model>) => Promise<IHttpResponse>;\n    /** Properties for the parameters' merging. */\n    interface IMergeProps<Model extends ILlmSchema.Model> {\n        /** Metadata of the target function. */\n        function: ILlmFunction<Model>;\n        /** Arguments composed by the LLM. */\n        llm: object | null;\n        /** Arguments composed by the human. */\n        human: object | null;\n    }\n    /**\n     * Merge the parameters.\n     *\n     * If you've configured the {@link IHttpLlmApplication.IOptions.separate}\n     * option, so that the parameters are separated to human and LLM sides, you\n     * can merge these humand and LLM sides' parameters into one through this\n     * `HttpLlm.mergeParameters()` function before the actual LLM function call\n     * wexecution.\n     *\n     * On contrary, if you've not configured the\n     * {@link IHttpLlmApplication.IOptions.separate} option, this function would\n     * throw an error.\n     *\n     * @param props Properties for the parameters' merging\n     * @returns Merged parameter values\n     */\n    const mergeParameters: <Model extends ILlmSchema.Model>(props: IMergeProps<Model>) => object;\n    /**\n     * Merge two values.\n     *\n     * If both values are objects, then combines them in the properties level.\n     *\n     * Otherwise, returns the latter value if it's not null, otherwise the former\n     * value.\n     *\n     * - `return (y ?? x)`\n     *\n     * @param x Value X to merge\n     * @param y Value Y to merge\n     * @returns Merged value\n     */\n    const mergeValue: (x: unknown, y: unknown) => unknown;\n}\n",
   "node_modules/@samchon/openapi/lib/HttpMigration.d.ts": "import { OpenApi } from \"./OpenApi\";\nimport { OpenApiV3 } from \"./OpenApiV3\";\nimport { OpenApiV3_1 } from \"./OpenApiV3_1\";\nimport { SwaggerV2 } from \"./SwaggerV2\";\nimport { IHttpConnection } from \"./structures/IHttpConnection\";\nimport { IHttpMigrateApplication } from \"./structures/IHttpMigrateApplication\";\nimport { IHttpMigrateRoute } from \"./structures/IHttpMigrateRoute\";\nimport { IHttpResponse } from \"./structures/IHttpResponse\";\n/**\n * HTTP migration application composer from OpenAPI document.\n *\n * `HttpMigration` is a module for composing HTTP migration application from the\n * {@link OpenApi.IDocument OpenAPI document}. It is designed for helping the\n * OpenAPI generator libraries, which converts\n * {@link OpenApi.IOperation OpenAPI operations} to an RPC (Remote Procedure\n * Call) function.\n *\n * The key feature of the `HttpModule` is the {@link HttpMigration.application}\n * function. It converts the {@link OpenApi.IOperation OpenAPI operations} to the\n * {@link IHttpMigrateRoute HTTP migration route}, and it normalizes the OpenAPI\n * operations to the RPC function calling suitable route structure.\n *\n * The other functions, {@link HttpMigration.execute} and\n * {@link HttpMigration.propagate}, are for executing the HTTP request to the\n * HTTP server. The {@link HttpMigration.execute} function returns the response\n * body from the API endpoint when the status code is `200` or `201`. Otherwise,\n * it throws an {@link HttpError} when the status code is not `200` or `201`. The\n * {@link HttpMigration.propagate} function returns the response information from\n * the API endpoint, including the status code, headers, and response body.\n *\n * The {@link HttpLlm} module is a good example utilizing this `HttpMigration`\n * module for composing RPC function calling application. The {@link HttpLlm}\n * module composes LLM (Large Language Model) function calling application from\n * the OpenAPI document bypassing through the {@link IHttpLlmApplication} type.\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace HttpMigration {\n    /**\n     * Convert HTTP migration application from OpenAPI document.\n     *\n     * `HttpMigration.application()` is a function converting the\n     * {@link OpenApi.IDocument OpenAPI document} and its\n     * {@link OpenApi.IOperation operations} to the\n     * {@link IHttpMigrateApplication HTTP migration application}.\n     *\n     * The HTTP migration application is designed for helping the OpenAPI\n     * generator libraries, which converts OpenAPI operations to an RPC (Remote\n     * Procedure Call) function. To support the OpenAPI generator libraries,\n     * {@link IHttpMigrateRoute} takes below normalization rules:\n     *\n     * - Path parameters are separated to atomic level.\n     * - Query parameters are binded into one object.\n     * - Header parameters are binded into one object.\n     * - Allow only below HTTP methods\n     *\n     *   - `head`\n     *   - `get`\n     *   - `post`\n     *   - `put`\n     *   - `patch`\n     *   - `delete`\n     * - Allow only below content media types\n     *\n     *   - `application/json`\n     *   - `application/x-www-form-urlencoded`\n     *   - `multipart/form-data`\n     *   - `text/plain`\n     *\n     * If there're some {@link OpenApi.IOperation API operations} which canont\n     * adjust the above rules or there're some logically insensible, these\n     * operation would be failed to migrate and registered into the\n     * {@link IHttpMigrateApplication.errors}.\n     *\n     * @param document OpenAPI document to migrate.\n     * @returns Migrated application.\n     */\n    const application: (document: OpenApi.IDocument | SwaggerV2.IDocument | OpenApiV3.IDocument | OpenApiV3_1.IDocument) => IHttpMigrateApplication;\n    /** Properties for the request to the HTTP server. */\n    interface IFetchProps {\n        /** Connection info to the HTTP server. */\n        connection: IHttpConnection;\n        /** Route information for the migration. */\n        route: IHttpMigrateRoute;\n        /**\n         * Path parameters.\n         *\n         * Path parameters with sequenced array or key-value paired object.\n         */\n        parameters: Array<string | number | boolean | bigint | null> | Record<string, string | number | boolean | bigint | null>;\n        /** Query parameters as a key-value paired object. */\n        query?: object | undefined;\n        /** Request body data. */\n        body?: object | undefined;\n    }\n    /**\n     * Execute the HTTP request.\n     *\n     * `HttpMigration.execute()` is a function executing the HTTP request to the\n     * HTTP server.\n     *\n     * It returns the response body from the API endpoint when the status code is\n     * `200` or `201`. Otherwise, it throws an {@link HttpError} when the status\n     * code is not `200` or `201`.\n     *\n     * If you want to get more information than the response body, or get the\n     * detailed response information even when the status code is `200` or `201`,\n     * use the {@link HttpMigration.propagate} function instead.\n     *\n     * @param props Properties for the request.\n     * @returns Return value (response body) from the API endpoint.\n     * @throws HttpError when the API endpoint responds none 200/201 status.\n     */\n    const execute: (props: IFetchProps) => Promise<unknown>;\n    /**\n     * Propagate the HTTP request.\n     *\n     * `HttpMigration.propagate()` is a function propagating the request to the\n     * HTTP server.\n     *\n     * It returns the response information from the API endpoint, including the\n     * status code, headers, and response body.\n     *\n     * Even if the status code is not `200` or `201`, this function would return\n     * the response information. By the way, if the connection to the HTTP server\n     * is failed, this function would throw an {@link Error}.\n     *\n     * @param props Properties for the request.\n     * @returns Response from the API endpoint.\n     * @throws Error when the connection is failed.\n     */\n    const propagate: (props: IFetchProps) => Promise<IHttpResponse>;\n}\n",
   "node_modules/@samchon/openapi/lib/McpLlm.d.ts": "import { ILlmSchema } from \"./structures/ILlmSchema\";\nimport { IMcpLlmApplication } from \"./structures/IMcpLlmApplication\";\nimport { IMcpTool } from \"./structures/IMcpTool\";\n/**\n * Application of LLM function calling from MCP document.\n *\n * `McpLlm` is a module for composing LLM (Large Language Model) function\n * calling application from MCP (Model Context Protocol) document.\n *\n * The reasons why `@samchon/openapi` recommends to use the function calling\n * feature instead of directly using the\n * [`mcp_servers`](https://openai.github.io/openai-agents-python/mcp/#using-mcp-servers)\n * property of LLM API are:\n *\n * - Model Specification: {@link ILlmSchema}\n * - Validation Feedback: {@link IMcpLlmFunction.validate}\n * - Selector agent for reducing context: [Agentica > Orchestration\n *   Strategy](https://wrtnlabs.io/agentica/docs/concepts/function-calling/#orchestration-strategy)\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport declare namespace McpLlm {\n    /**\n     * Properties for the LLM function calling application composer.\n     *\n     * @template Model Target LLM model\n     */\n    interface IApplicationProps<Model extends ILlmSchema.Model> {\n        /** Target LLM model. */\n        model: Model;\n        /**\n         * List of tools.\n         *\n         * A list of tools defined in the MCP (Model Context Protocol) document.\n         *\n         * It is better to validate the tools using the\n         * [`typia.assert<T>()`](https://typia.io/docs/validate/assert) function for\n         * type safety.\n         */\n        tools: Array<IMcpTool>;\n        /** Options for the LLM function calling schema conversion. */\n        options?: Partial<IMcpLlmApplication.IOptions<Model>>;\n    }\n    /**\n     * Convert MCP document to LLM function calling application.\n     *\n     * Converts MCP (Model Context Protocol) to LLM (Large Language Model)\n     * function calling application.\n     *\n     * The reasons why `@samchon/openapi` recommends using the function calling\n     * feature instead of directly using the\n     * [`mcp_servers`](https://openai.github.io/openai-agents-python/mcp/#using-mcp-servers)\n     * property of LLM API are:\n     *\n     * - **Model Specification**: {@link ILlmSchema}\n     * - **Validation Feedback**: {@link IMcpLlmFunction.validate}\n     * - **Selector agent for reducing context**: [Agentica > Orchestration\n     *   Strategy](https://wrtnlabs.io/agentica/docs/concepts/function-calling/#orchestration-strategy)\n     *\n     * @param props Properties for composition\n     * @returns LLM function calling application\n     */\n    const application: <Model extends ILlmSchema.Model>(props: IApplicationProps<Model>) => IMcpLlmApplication<Model>;\n}\n",
@@ -131,7 +131,7 @@
   "node_modules/@samchon/openapi/lib/utils/internal/OpenApiStringValidator.d.ts": "import { OpenApi } from \"../../OpenApi\";\nimport { IOpenApiValidatorContext } from \"./IOpenApiValidatorContext\";\nexport declare namespace OpenApiStringValidator {\n    const validate: (ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IString>) => boolean;\n}\n",
   "node_modules/@samchon/openapi/lib/utils/internal/OpenApiTupleValidator.d.ts": "import { OpenApi } from \"../../OpenApi\";\nimport { IOpenApiValidatorContext } from \"./IOpenApiValidatorContext\";\nexport declare namespace OpenApiTupleValidator {\n    const validate: (ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.ITuple>) => boolean;\n}\n",
   "node_modules/@samchon/openapi/lib/utils/internal/OpenApiTypeCheckerBase.d.ts": "export {};\n",
-  "node_modules/@samchon/openapi/package.json": "{\n  \"name\": \"@samchon/openapi\",\n  \"version\": \"5.0.0\",\n  \"description\": \"OpenAPI definitions and converters for 'typia' and 'nestia'.\",\n  \"main\": \"./lib/index.js\",\n  \"module\": \"./lib/index.mjs\",\n  \"typings\": \"./lib/index.d.ts\",\n  \"scripts\": {\n    \"prepare\": \"ts-patch install\",\n    \"build\": \"rimraf lib && tsc && rollup -c && ts-node build/post.ts\",\n    \"dev\": \"rimraf lib && tsc --watch\",\n    \"typedoc\": \"typedoc --plugin typedoc-github-theme --theme typedoc-github-theme\"\n  },\n  \"keywords\": [\n    \"swagger\",\n    \"openapi\",\n    \"openapi-generator\",\n    \"openapi-validator\",\n    \"converter\",\n    \"migrate\",\n    \"typia\",\n    \"nestia\",\n    \"llm\",\n    \"llm-function-calling\",\n    \"structured-output\",\n    \"openai\",\n    \"chatgpt\",\n    \"claude\",\n    \"gemini\",\n    \"llama\"\n  ],\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/openapi\"\n  },\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/openapi/issues\"\n  },\n  \"homepage\": \"https://samchon.github.io/openapi/api\",\n  \"devDependencies\": {\n    \"@modelcontextprotocol/sdk\": \"^1.11.4\",\n    \"@rollup/plugin-terser\": \"^0.4.4\",\n    \"@rollup/plugin-typescript\": \"^12.1.2\",\n    \"@trivago/prettier-plugin-sort-imports\": \"^5.2.2\",\n    \"@types/node\": \"^20.12.7\",\n    \"gh-pages\": \"^6.3.0\",\n    \"prettier\": \"^3.5.3\",\n    \"prettier-plugin-jsdoc\": \"^1.3.2\",\n    \"rimraf\": \"^5.0.5\",\n    \"rollup\": \"^4.18.1\",\n    \"rollup-plugin-auto-external\": \"^2.0.0\",\n    \"tinyglobby\": \"^0.2.10\",\n    \"ts-node\": \"^10.9.2\",\n    \"ts-patch\": \"^3.3.0\",\n    \"typedoc\": \"^0.27.6\",\n    \"typedoc-github-theme\": \"^0.2.1\",\n    \"typescript\": \"~5.8.3\"\n  },\n  \"sideEffects\": false,\n  \"files\": [\n    \"lib\",\n    \"src\",\n    \"README.md\",\n    \"LICENSE\"\n  ],\n  \"packageManager\": \"pnpm@10.5.2\",\n  \"pnpm\": {\n    \"executionEnv\": {\n      \"nodeVersion\": \"22.14.0\"\n    },\n    \"onlyBuiltDependencies\": [\n      \"@nestjs/core\"\n    ]\n  }\n}\n",
+  "node_modules/@samchon/openapi/package.json": "{\n  \"name\": \"@samchon/openapi\",\n  \"version\": \"5.0.1\",\n  \"description\": \"OpenAPI definitions and converters for 'typia' and 'nestia'.\",\n  \"main\": \"./lib/index.js\",\n  \"module\": \"./lib/index.mjs\",\n  \"typings\": \"./lib/index.d.ts\",\n  \"scripts\": {\n    \"prepare\": \"ts-patch install\",\n    \"build\": \"rimraf lib && tsc && rollup -c && ts-node build/post.ts\",\n    \"dev\": \"rimraf lib && tsc --watch\",\n    \"typedoc\": \"typedoc --plugin typedoc-github-theme --theme typedoc-github-theme\"\n  },\n  \"keywords\": [\n    \"swagger\",\n    \"openapi\",\n    \"openapi-generator\",\n    \"openapi-validator\",\n    \"converter\",\n    \"migrate\",\n    \"typia\",\n    \"nestia\",\n    \"llm\",\n    \"llm-function-calling\",\n    \"structured-output\",\n    \"openai\",\n    \"chatgpt\",\n    \"claude\",\n    \"gemini\",\n    \"llama\"\n  ],\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/openapi\"\n  },\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/openapi/issues\"\n  },\n  \"homepage\": \"https://samchon.github.io/openapi/api\",\n  \"devDependencies\": {\n    \"@modelcontextprotocol/sdk\": \"^1.11.4\",\n    \"@rollup/plugin-terser\": \"^0.4.4\",\n    \"@rollup/plugin-typescript\": \"^12.1.2\",\n    \"@trivago/prettier-plugin-sort-imports\": \"^5.2.2\",\n    \"@types/node\": \"^20.12.7\",\n    \"gh-pages\": \"^6.3.0\",\n    \"prettier\": \"^3.5.3\",\n    \"prettier-plugin-jsdoc\": \"^1.3.2\",\n    \"rimraf\": \"^5.0.5\",\n    \"rollup\": \"^4.18.1\",\n    \"rollup-plugin-auto-external\": \"^2.0.0\",\n    \"tinyglobby\": \"^0.2.10\",\n    \"ts-node\": \"^10.9.2\",\n    \"ts-patch\": \"^3.3.0\",\n    \"typedoc\": \"^0.27.6\",\n    \"typedoc-github-theme\": \"^0.2.1\",\n    \"typescript\": \"~5.8.3\"\n  },\n  \"sideEffects\": false,\n  \"files\": [\n    \"lib\",\n    \"src\",\n    \"README.md\",\n    \"LICENSE\"\n  ],\n  \"packageManager\": \"pnpm@10.5.2\",\n  \"pnpm\": {\n    \"executionEnv\": {\n      \"nodeVersion\": \"22.14.0\"\n    },\n    \"onlyBuiltDependencies\": [\n      \"@nestjs/core\"\n    ]\n  }\n}\n",
   "node_modules/@standard-schema/spec/dist/index.d.ts": "/** The Standard Schema interface. */\ninterface StandardSchemaV1<Input = unknown, Output = Input> {\n    /** The Standard Schema properties. */\n    readonly \"~standard\": StandardSchemaV1.Props<Input, Output>;\n}\ndeclare namespace StandardSchemaV1 {\n    /** The Standard Schema properties interface. */\n    export interface Props<Input = unknown, Output = Input> {\n        /** The version number of the standard. */\n        readonly version: 1;\n        /** The vendor name of the schema library. */\n        readonly vendor: string;\n        /** Validates unknown input values. */\n        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;\n        /** Inferred types associated with the schema. */\n        readonly types?: Types<Input, Output> | undefined;\n    }\n    /** The result interface of the validate function. */\n    export type Result<Output> = SuccessResult<Output> | FailureResult;\n    /** The result interface if validation succeeds. */\n    export interface SuccessResult<Output> {\n        /** The typed output value. */\n        readonly value: Output;\n        /** The non-existent issues. */\n        readonly issues?: undefined;\n    }\n    /** The result interface if validation fails. */\n    export interface FailureResult {\n        /** The issues of failed validation. */\n        readonly issues: ReadonlyArray<Issue>;\n    }\n    /** The issue interface of the failure output. */\n    export interface Issue {\n        /** The error message of the issue. */\n        readonly message: string;\n        /** The path of the issue, if any. */\n        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;\n    }\n    /** The path segment interface of the issue. */\n    export interface PathSegment {\n        /** The key representing a path segment. */\n        readonly key: PropertyKey;\n    }\n    /** The Standard Schema types interface. */\n    export interface Types<Input = unknown, Output = Input> {\n        /** The input type of the schema. */\n        readonly input: Input;\n        /** The output type of the schema. */\n        readonly output: Output;\n    }\n    /** Infers the input type of a Standard Schema. */\n    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema[\"~standard\"][\"types\"]>[\"input\"];\n    /** Infers the output type of a Standard Schema. */\n    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema[\"~standard\"][\"types\"]>[\"output\"];\n    export {  };\n}\n\nexport { StandardSchemaV1 };\n",
   "node_modules/@standard-schema/spec/package.json": "{\n  \"name\": \"@standard-schema/spec\",\n  \"description\": \"A standard interface for TypeScript schema validation libraries\",\n  \"version\": \"1.0.0\",\n  \"license\": \"MIT\",\n  \"author\": \"Colin McDonnell\",\n  \"homepage\": \"https://standardschema.dev\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/standard-schema/standard-schema\"\n  },\n  \"keywords\": [\n    \"typescript\",\n    \"schema\",\n    \"validation\",\n    \"standard\",\n    \"interface\"\n  ],\n  \"type\": \"module\",\n  \"main\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/index.d.ts\",\n        \"default\": \"./dist/index.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/index.d.cts\",\n        \"default\": \"./dist/index.cjs\"\n      }\n    }\n  },\n  \"sideEffects\": false,\n  \"files\": [\n    \"dist\"\n  ],\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"devDependencies\": {\n    \"tsup\": \"^8.3.0\",\n    \"typescript\": \"^5.6.2\"\n  },\n  \"scripts\": {\n    \"lint\": \"pnpm biome lint ./src\",\n    \"format\": \"pnpm biome format --write ./src\",\n    \"check\": \"pnpm biome check ./src\",\n    \"build\": \"tsup\"\n  }\n}",
   "node_modules/@types/node/assert/strict.d.ts": "declare module \"assert/strict\" {\n    import { strict } from \"node:assert\";\n    export = strict;\n}\ndeclare module \"node:assert/strict\" {\n    import { strict } from \"node:assert\";\n    export = strict;\n}\n",
@@ -867,10 +867,10 @@
   "node_modules/typia/lib/internal/_validateReport.d.ts": "import { IValidation } from \"../IValidation\";\nexport declare const _validateReport: (array: IValidation.IError[]) => (exceptable: boolean, error: IValidation.IError) => false;\n",
   "node_modules/typia/lib/internal/private/__notationCapitalize.d.ts": "export declare const __notationCapitalize: (str: string) => string;\n",
   "node_modules/typia/lib/internal/private/__notationUnsnake.d.ts": "export declare const __notationUnsnake: (props: {\n    plain: (str: string) => string;\n    snake: (str: string, index: number) => string;\n}) => (str: string) => string;\n",
-  "node_modules/typia/lib/json.d.ts": "import { IJsonSchemaCollection } from \"./schemas/json/IJsonSchemaCollection\";\nimport { IJsonSchemaUnit } from \"./schemas/json/IJsonSchemaUnit\";\nimport { IValidation } from \"./IValidation\";\nimport { Primitive } from \"./Primitive\";\nimport { TypeGuardError } from \"./TypeGuardError\";\n/**\n * > You must configure the generic argument `Types`.\n *\n * JSON Schemas Generator.\n *\n * Creates a JSON schema list which contains both main JSON schemas and\n * components. Note that, all of the named types are stored in the\n * {@link IJsonSchemaCollection.components} property for the `$ref` referencing.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and the\n * key difference between `\"3.0\"` and `\"3.1\"` is whether supporting the tuple\n * type or not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Types Tuple of target types\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON schema collection\n */\nexport declare function schemas(): never;\n/**\n * JSON Schemas Generator.\n *\n * Creates a JSON schema list which contains both main JSON schemas and\n * components. Note that, all of the named types are stored in the\n * {@link IJsonSchemaCollection.components} property for the `$ref` referencing.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and the\n * key difference between `\"3.0\"` and `\"3.1\"` is whether supporting the tuple\n * type or not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Types Tuple of target types\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON schema collection\n */\nexport declare function schemas<Types extends unknown[], Version extends \"3.0\" | \"3.1\" = \"3.1\">(): IJsonSchemaCollection<Version, Types>;\n/**\n * > You must configure the generic argument `Type`.\n *\n * JSON schema generator.\n *\n * Creates a JSON schema unit which contains a main JSON schema and its\n * components. Note that, all of the named types are stored in the\n * {@link IJsonSchemaUnit.components} property for the `$ref` referencing.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and key\n * different of `\"3.0\"` and `\"3.1\"` is whether supporting the tuple type or\n * not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Type Target type\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON schema unit\n */\nexport declare function schema(): never;\n/**\n * JSON schema generator.\n *\n * Creates a JSON schema unit which contains a main JSON schema and its\n * components. Note that, all of the named types are stored in the\n * {@link IJsonSchemaUnit.components} property for the `$ref` referencing.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and key\n * different of `\"3.0\"` and `\"3.1\"` is whether supporting the tuple type or\n * not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Type Target type\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON schema unit\n */\nexport declare function schema<Type extends unknown, Version extends \"3.0\" | \"3.1\" = \"3.1\">(): IJsonSchemaUnit<Version, Type>;\n/**\n * > You must configure the generic argument `T`.\n *\n * Safe `JSON.parse()` function with type assertion.\n *\n * `typia.json.assertParse()` is a combination function of `JSON.parse()` and\n * {@link assert}. Therefore, it converts a JSON (JavaScript Object Notation)\n * string to a `T` typed instance with type assertion.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it throws {@link TypeGuardError} or custom error generated by\n * _errorFactory_. Otherwise, if there's no problem with the parsed value, the\n * parsed value will be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parsed value\n */\nexport declare function assertParse(input: string, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Safe `JSON.parse()` function with type assertion.\n *\n * `typia.json.assertParse()` is a combination function of `JSON.parse()` and\n * {@link assert}. Therefore, it converts a JSON (JavaScript Object Notation)\n * string to a `T` typed instance with type assertion.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it throws {@link TypeGuardError} or custom error generated by\n * _errorFactory_. Otherwise, there's no problem on the parsed value, the parsed\n * value would be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parsed value\n */\nexport declare function assertParse<T>(input: string, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): Primitive<T>;\n/**\n * > You must configure the generic argument `T`.\n *\n * Safe `JSON.parse()` function with type checking.\n *\n * `typia.json.isParse()` is a combination function of `JSON.parse()` and\n * {@link is}. Therefore, it converts a JSON (JavaScript Object Notation) string\n * to a `T` typed instance with type checking.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it returns `null` value. Otherwise, there's no problem on the parsed\n * value, the parsed value will be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @returns Parsed value when exact type, otherwise `null`\n */\nexport declare function isParse(input: string): never;\n/**\n * Safe `JSON.parse()` function with type checking.\n *\n * `typia.json.isParse()` is a combination function of `JSON.parse()` and\n * {@link is}. Therefore, it converts a JSON (JavaScript Object Notation) string\n * to a `T` typed instance with type checking.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it returns `null` value. Otherwise, there's no problem on the parsed\n * value, the parsed value will be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @returns Parsed value when exact type, otherwise `null`\n */\nexport declare function isParse<T>(input: string): Primitive<T> | null;\n/**\n * > You must configure the generic argument `T`.\n *\n * Safe `JSON.parse()` function with detailed type validation.\n *\n * `typia.json.validateParse()` is a combination function of `JSON.parse()` and\n * {@link validate}. Therefore, it converts a JSON (JavaScript Object Notation)\n * string to a `T` typed instance with detailed type validation.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it returns {@link IValidation.IFailure} value with detailed error\n * reasons. Otherwise, there's no problem on the parsed value, the parsed value\n * will be stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @returns Validation result with JSON parsed value\n */\nexport declare function validateParse(input: string): never;\n/**\n * Safe `JSON.parse()` function with detailed type validation.\n *\n * `typia.json.validateParse()` is a combination function of `JSON.parse()` and\n * {@link validate}. Therefore, it converts a JSON (JavaScript Object Notation)\n * string to a `T` typed instance with detailed type validation.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it returns {@link IValidation.IFailure} value with detailed error\n * reasons. Otherwise, there's no problem on the parsed value, the parsed value\n * will be stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @returns Validation result with JSON parsed value\n */\nexport declare function validateParse<T>(input: string): IValidation<Primitive<T>>;\n/**\n * 8x faster `JSON.stringify()` function.\n *\n * Converts an input value to a JSON (JavaScript Object Notation) string, about\n * 8x faster than the native `JSON.stringify()` function. The 5x faster\n * principle is because it writes an optimized JSON conversion plan, only for\n * the type `T`.\n *\n * For reference, this `typia.json.stringify()` does not validate the input\n * value type. It just believes that the input value is following the type `T`.\n * Therefore, if you can't ensure the input value type, it will be better to\n * call one of below functions instead.\n *\n * - {@link assertStringify}\n * - {@link isStringify}\n * - {@link validateStringify}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be converted\n * @returns JSON string value\n */\nexport declare function stringify<T>(input: T): string;\n/**\n * 5x faster `JSON.stringify()` function with type assertion.\n *\n * `typia.json.assertStringify()` is a combination function of {@link assert} and\n * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript\n * Object Notation) string, with type assertion.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * throws an {@link TypeGuardError} or custom error generated by _errorFactory_.\n * Otherwise, there's no problem on the `input` value, JSON string will be\n * returned.\n *\n * For reference, with type assertion, it is even 5x times faster than the\n * native `JSON.stringify()` function. So, just enjoy the safe and fast JSON\n * conversion with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted and converted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns JSON string value\n */\nexport declare function assertStringify<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): string;\n/**\n * 5x faster `JSON.stringify()` function with type assertion.\n *\n * `typia.json.assertStringify()` is a combination function of {@link assert} and\n * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript\n * Object Notation) string, with type assertion.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * throws an {@link TypeGuardError} or custom error generated by _errorFactory_.\n * Otherwise, there's no problem on the `input` value, JSON string will be\n * returned.\n *\n * For reference, with type assertion, it is even 5x times faster than the\n * native `JSON.stringify()` function. So, just enjoy the safe and fast JSON\n * conversion with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted and converted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns JSON string value\n */\nexport declare function assertStringify<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): unknown;\n/**\n * 7x faster `JSON.stringify()` function with type checking.\n *\n * `typia.json.stringify()` is a combination function of {@link is} and\n * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript\n * Object Notation) string, with type checking.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns `null` value. Otherwise, there's no problem on the `input` value,\n * JSON string will be returned.\n *\n * For reference, with type checking, it is even 7x times faster than the native\n * `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion\n * with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be checked and converted\n * @returns JSON string value when exact type, otherwise null\n */\nexport declare function isStringify<T>(input: T): string | null;\n/**\n * 7x faster `JSON.stringify()` function with type checking.\n *\n * `typia.json.isStringify()` is a combination function of {@link is} and\n * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript\n * Object Notation) string, with type checking.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns `null` value. Otherwise, there's no problem on the `input` value,\n * JSON string will be returned.\n *\n * For reference, with type checking, it is even 7x times faster than the native\n * `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion\n * with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be checked and converted\n * @returns JSON string value when exact type, otherwise null\n */\nexport declare function isStringify<T>(input: unknown): string | null;\n/**\n * 5x faster `JSON.stringify()` function with detailed type validation.\n *\n * `typia.json.validateStringify()` is a combination function of {@link validate}\n * and {@link stringify}. Therefore, it converts an input value to JSON\n * (JavaScript Object Notation) string, with detailed type validation.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns {@link IValidation.IFailure} value with detailed error reasons.\n * Otherwise, there's no problem on the `input` value, JSON string will be\n * stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * For reference, with detailed type validation, it is even 5x times faster than\n * the native `JSON.stringify()` function. So, just enjoy the safe and fast JSON\n * conversion with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be checked and converted\n * @returns Validation result with JSON string value\n */\nexport declare function validateStringify<T>(input: T): IValidation<string>;\n/**\n * 5x faster `JSON.stringify()` function with detailed type validation.\n *\n * `typia.json.validateStringify()` is a combination function of {@link validate}\n * and {@link stringify}. Therefore, it converts an input value to JSON\n * (JavaScript Object Notation) string, with detailed type validation.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns {@link IValidation.IFailure} value with detailed error reasons.\n * Otherwise, there's no problem on the `input` value, JSON string will be\n * stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * For reference, with detailed type validation, it is even 5x times faster than\n * the native `JSON.stringify()` function. So, just enjoy the safe and fast JSON\n * conversion with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be checked and converted\n * @returns Validation result with JSON string value\n */\nexport declare function validateStringify<T>(input: unknown): IValidation<string>;\n/**\n * Creates a reusable {@link isParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsParse(): never;\n/**\n * Creates a reusable {@link isParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @returns A reusable `isParse` function\n */\nexport declare function createIsParse<T>(): (input: string) => Primitive<T> | null;\n/**\n * Creates a reusable {@link assertParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertParse(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertParse` function\n */\nexport declare function createAssertParse<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: string) => Primitive<T>;\n/**\n * Creates a reusable {@link validateParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateParse(): never;\n/**\n * Creates a reusable {@link validateParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @returns A reusable `validateParse` function\n */\nexport declare function createValidateParse<T>(): (input: string) => IValidation<Primitive<T>>;\n/**\n * Creates a reusable {@link stringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createStringify(): never;\n/**\n * Creates a reusable {@link stringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `stringify` function\n */\nexport declare function createStringify<T>(): (input: T) => string;\n/**\n * Creates a reusable {@link assertStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertStringify(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertStringify` function\n */\nexport declare function createAssertStringify<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => string;\n/**\n * Creates a reusable {@link isStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsStringify(): never;\n/**\n * Creates a reusable {@link isStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `isStringify` function\n */\nexport declare function createIsStringify<T>(): (input: unknown) => string | null;\n/**\n * Creates a reusable {@link validateStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateStringify(): never;\n/**\n * Creates a reusable {@link validateStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validateStringify` function\n */\nexport declare function createValidateStringify<T>(): (input: unknown) => IValidation<string>;\n",
+  "node_modules/typia/lib/json.d.ts": "import { IJsonSchemaApplication } from \"./schemas/json/IJsonSchemaApplication\";\nimport { IJsonSchemaCollection } from \"./schemas/json/IJsonSchemaCollection\";\nimport { IJsonSchemaUnit } from \"./schemas/json/IJsonSchemaUnit\";\nimport { IValidation } from \"./IValidation\";\nimport { Primitive } from \"./Primitive\";\nimport { TypeGuardError } from \"./TypeGuardError\";\n/**\n * > You must configure the generic argument `Type`.\n *\n * JSON schema generator.\n *\n * Creates a JSON schema unit which contains a main JSON schema and its\n * components. Note that, all of the named types are stored in the\n * {@link IJsonSchemaUnit.components} property for the `$ref` referencing.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and key\n * different of `\"3.0\"` and `\"3.1\"` is whether supporting the tuple type or\n * not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Type Target type\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON schema unit\n */\nexport declare function schema(): never;\n/**\n * JSON schema generator.\n *\n * Creates a JSON schema unit which contains a main JSON schema and its\n * components. Note that, all of the named types are stored in the\n * {@link IJsonSchemaUnit.components} property for the `$ref` referencing.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and key\n * different of `\"3.0\"` and `\"3.1\"` is whether supporting the tuple type or\n * not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Type Target type\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON schema unit\n */\nexport declare function schema<Type extends unknown, Version extends \"3.0\" | \"3.1\" = \"3.1\">(): IJsonSchemaUnit<Version, Type>;\n/**\n * > You must configure the generic argument `Types`.\n *\n * JSON Schemas Generator.\n *\n * Creates a JSON schema list which contains both main JSON schemas and\n * components. Note that, all of the named types are stored in the\n * {@link IJsonSchemaCollection.components} property for the `$ref` referencing.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and the\n * key difference between `\"3.0\"` and `\"3.1\"` is whether supporting the tuple\n * type or not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Types Tuple of target types\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON schema collection\n */\nexport declare function schemas(): never;\n/**\n * JSON Schemas Generator.\n *\n * Creates a JSON schema list which contains both main JSON schemas and\n * components. Note that, all of the named types are stored in the\n * {@link IJsonSchemaCollection.components} property for the `$ref` referencing.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and the\n * key difference between `\"3.0\"` and `\"3.1\"` is whether supporting the tuple\n * type or not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Types Tuple of target types\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON schema collection\n */\nexport declare function schemas<Types extends unknown[], Version extends \"3.0\" | \"3.1\" = \"3.1\">(): IJsonSchemaCollection<Version, Types>;\n/**\n * > You must configure the generic argument `Class`.\n *\n * TypeScript class to JSON function schema application.\n *\n * Creates a JSON function schema application from a TypeScript class or\n * interface type containing the target functions. This is an intermediate-level\n * function designed for professional developers who want to build custom LLM\n * function calling schemas or need to transform class methods into structured\n * JSON schema representations.\n *\n * Unlike {@link schema} which creates a schema for a single type, this function\n * analyzes an entire class/interface and generates JSON schemas for all its\n * methods, their parameters, and return types. The returned\n * {@link IJsonSchemaApplication} contains:\n *\n * - {@link IJsonSchemaApplication.functions}: Array of function metadata with\n *   parameter and return type schemas\n * - {@link IJsonSchemaApplication.components}: Shared schema components for `$ref`\n *   referencing\n *\n * This function serves as the underlying implementation for\n * {@link llm.application}, and can be used when you need to:\n *\n * - Create your own custom LLM function calling schema format\n * - Transform class methods into structured JSON schema format\n * - Build API documentation or code generation tools\n * - Develop alternative LLM integrations beyond the built-in providers\n *\n * For direct LLM function calling implementations, consider using\n * {@link llm.application} instead, which provides provider-specific schemas for\n * ChatGPT, Claude, Gemini, and other LLM providers.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and the\n * key difference between `\"3.0\"` and `\"3.1\"` is whether supporting the tuple\n * type or not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Class Target class or interface type containing the functions\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON function schema application\n */\nexport declare function application(): never;\n/**\n * TypeScript class to JSON function schema application.\n *\n * Creates a JSON function schema application from a TypeScript class or\n * interface type containing the target functions. This is an intermediate-level\n * function designed for professional developers who want to build custom LLM\n * function calling schemas or need to transform class methods into structured\n * JSON schema representations.\n *\n * Unlike {@link schema} which creates a schema for a single type, this function\n * analyzes an entire class/interface and generates JSON schemas for all its\n * methods, their parameters, and return types. The returned\n * {@link IJsonSchemaApplication} contains:\n *\n * - {@link IJsonSchemaApplication.functions}: Array of function metadata with\n *   parameter and return type schemas\n * - {@link IJsonSchemaApplication.components}: Shared schema components for `$ref`\n *   referencing\n *\n * This function serves as the underlying implementation for\n * {@link llm.application}, and can be used when you need to:\n *\n * - Create your own custom LLM function calling schema format\n * - Transform class methods into structured JSON schema format\n * - Build API documentation or code generation tools\n * - Develop alternative LLM integrations beyond the built-in providers\n *\n * For direct LLM function calling implementations, consider using\n * {@link llm.application} instead, which provides provider-specific schemas for\n * ChatGPT, Claude, Gemini, and other LLM providers.\n *\n * Also, you can specify the OpenAPI version by configuring the second generic\n * argument `Version`. For reference, the default version is `\"3.1\"`, and the\n * key difference between `\"3.0\"` and `\"3.1\"` is whether supporting the tuple\n * type or not.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Class Target class or interface type containing the functions\n * @template Version Version of OpenAPI specification. Default is 3.1\n * @returns JSON function schema application\n */\nexport declare function application<Class extends object, Version extends \"3.0\" | \"3.1\" = \"3.1\">(): IJsonSchemaApplication<Version, Class>;\n/**\n * > You must configure the generic argument `T`.\n *\n * Safe `JSON.parse()` function with type assertion.\n *\n * `typia.json.assertParse()` is a combination function of `JSON.parse()` and\n * {@link assert}. Therefore, it converts a JSON (JavaScript Object Notation)\n * string to a `T` typed instance with type assertion.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it throws {@link TypeGuardError} or custom error generated by\n * _errorFactory_. Otherwise, if there's no problem with the parsed value, the\n * parsed value will be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parsed value\n */\nexport declare function assertParse(input: string, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Safe `JSON.parse()` function with type assertion.\n *\n * `typia.json.assertParse()` is a combination function of `JSON.parse()` and\n * {@link assert}. Therefore, it converts a JSON (JavaScript Object Notation)\n * string to a `T` typed instance with type assertion.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it throws {@link TypeGuardError} or custom error generated by\n * _errorFactory_. Otherwise, there's no problem on the parsed value, the parsed\n * value would be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parsed value\n */\nexport declare function assertParse<T>(input: string, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): Primitive<T>;\n/**\n * > You must configure the generic argument `T`.\n *\n * Safe `JSON.parse()` function with type checking.\n *\n * `typia.json.isParse()` is a combination function of `JSON.parse()` and\n * {@link is}. Therefore, it converts a JSON (JavaScript Object Notation) string\n * to a `T` typed instance with type checking.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it returns `null` value. Otherwise, there's no problem on the parsed\n * value, the parsed value will be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @returns Parsed value when exact type, otherwise `null`\n */\nexport declare function isParse(input: string): never;\n/**\n * Safe `JSON.parse()` function with type checking.\n *\n * `typia.json.isParse()` is a combination function of `JSON.parse()` and\n * {@link is}. Therefore, it converts a JSON (JavaScript Object Notation) string\n * to a `T` typed instance with type checking.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it returns `null` value. Otherwise, there's no problem on the parsed\n * value, the parsed value will be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @returns Parsed value when exact type, otherwise `null`\n */\nexport declare function isParse<T>(input: string): Primitive<T> | null;\n/**\n * > You must configure the generic argument `T`.\n *\n * Safe `JSON.parse()` function with detailed type validation.\n *\n * `typia.json.validateParse()` is a combination function of `JSON.parse()` and\n * {@link validate}. Therefore, it converts a JSON (JavaScript Object Notation)\n * string to a `T` typed instance with detailed type validation.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it returns {@link IValidation.IFailure} value with detailed error\n * reasons. Otherwise, there's no problem on the parsed value, the parsed value\n * will be stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @returns Validation result with JSON parsed value\n */\nexport declare function validateParse(input: string): never;\n/**\n * Safe `JSON.parse()` function with detailed type validation.\n *\n * `typia.json.validateParse()` is a combination function of `JSON.parse()` and\n * {@link validate}. Therefore, it converts a JSON (JavaScript Object Notation)\n * string to a `T` typed instance with detailed type validation.\n *\n * In such reason, when parsed JSON string value is not matched with the type\n * `T`, it returns {@link IValidation.IFailure} value with detailed error\n * reasons. Otherwise, there's no problem on the parsed value, the parsed value\n * will be stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param input JSON string\n * @returns Validation result with JSON parsed value\n */\nexport declare function validateParse<T>(input: string): IValidation<Primitive<T>>;\n/**\n * 8x faster `JSON.stringify()` function.\n *\n * Converts an input value to a JSON (JavaScript Object Notation) string, about\n * 8x faster than the native `JSON.stringify()` function. The 5x faster\n * principle is because it writes an optimized JSON conversion plan, only for\n * the type `T`.\n *\n * For reference, this `typia.json.stringify()` does not validate the input\n * value type. It just believes that the input value is following the type `T`.\n * Therefore, if you can't ensure the input value type, it will be better to\n * call one of below functions instead.\n *\n * - {@link assertStringify}\n * - {@link isStringify}\n * - {@link validateStringify}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be converted\n * @returns JSON string value\n */\nexport declare function stringify<T>(input: T): string;\n/**\n * 5x faster `JSON.stringify()` function with type assertion.\n *\n * `typia.json.assertStringify()` is a combination function of {@link assert} and\n * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript\n * Object Notation) string, with type assertion.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * throws an {@link TypeGuardError} or custom error generated by _errorFactory_.\n * Otherwise, there's no problem on the `input` value, JSON string will be\n * returned.\n *\n * For reference, with type assertion, it is even 5x times faster than the\n * native `JSON.stringify()` function. So, just enjoy the safe and fast JSON\n * conversion with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted and converted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns JSON string value\n */\nexport declare function assertStringify<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): string;\n/**\n * 5x faster `JSON.stringify()` function with type assertion.\n *\n * `typia.json.assertStringify()` is a combination function of {@link assert} and\n * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript\n * Object Notation) string, with type assertion.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * throws an {@link TypeGuardError} or custom error generated by _errorFactory_.\n * Otherwise, there's no problem on the `input` value, JSON string will be\n * returned.\n *\n * For reference, with type assertion, it is even 5x times faster than the\n * native `JSON.stringify()` function. So, just enjoy the safe and fast JSON\n * conversion with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted and converted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns JSON string value\n */\nexport declare function assertStringify<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): unknown;\n/**\n * 7x faster `JSON.stringify()` function with type checking.\n *\n * `typia.json.stringify()` is a combination function of {@link is} and\n * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript\n * Object Notation) string, with type checking.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns `null` value. Otherwise, there's no problem on the `input` value,\n * JSON string will be returned.\n *\n * For reference, with type checking, it is even 7x times faster than the native\n * `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion\n * with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be checked and converted\n * @returns JSON string value when exact type, otherwise null\n */\nexport declare function isStringify<T>(input: T): string | null;\n/**\n * 7x faster `JSON.stringify()` function with type checking.\n *\n * `typia.json.isStringify()` is a combination function of {@link is} and\n * {@link stringify}. Therefore, it converts an input value to JSON (JavaScript\n * Object Notation) string, with type checking.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns `null` value. Otherwise, there's no problem on the `input` value,\n * JSON string will be returned.\n *\n * For reference, with type checking, it is even 7x times faster than the native\n * `JSON.stringify()` function. So, just enjoy the safe and fast JSON conversion\n * with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be checked and converted\n * @returns JSON string value when exact type, otherwise null\n */\nexport declare function isStringify<T>(input: unknown): string | null;\n/**\n * 5x faster `JSON.stringify()` function with detailed type validation.\n *\n * `typia.json.validateStringify()` is a combination function of {@link validate}\n * and {@link stringify}. Therefore, it converts an input value to JSON\n * (JavaScript Object Notation) string, with detailed type validation.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns {@link IValidation.IFailure} value with detailed error reasons.\n * Otherwise, there's no problem on the `input` value, JSON string will be\n * stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * For reference, with detailed type validation, it is even 5x times faster than\n * the native `JSON.stringify()` function. So, just enjoy the safe and fast JSON\n * conversion with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be checked and converted\n * @returns Validation result with JSON string value\n */\nexport declare function validateStringify<T>(input: T): IValidation<string>;\n/**\n * 5x faster `JSON.stringify()` function with detailed type validation.\n *\n * `typia.json.validateStringify()` is a combination function of {@link validate}\n * and {@link stringify}. Therefore, it converts an input value to JSON\n * (JavaScript Object Notation) string, with detailed type validation.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns {@link IValidation.IFailure} value with detailed error reasons.\n * Otherwise, there's no problem on the `input` value, JSON string will be\n * stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * For reference, with detailed type validation, it is even 5x times faster than\n * the native `JSON.stringify()` function. So, just enjoy the safe and fast JSON\n * conversion with confidence.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be checked and converted\n * @returns Validation result with JSON string value\n */\nexport declare function validateStringify<T>(input: unknown): IValidation<string>;\n/**\n * Creates a reusable {@link isParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsParse(): never;\n/**\n * Creates a reusable {@link isParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @returns A reusable `isParse` function\n */\nexport declare function createIsParse<T>(): (input: string) => Primitive<T> | null;\n/**\n * Creates a reusable {@link assertParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertParse(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertParse` function\n */\nexport declare function createAssertParse<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: string) => Primitive<T>;\n/**\n * Creates a reusable {@link validateParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateParse(): never;\n/**\n * Creates a reusable {@link validateParse} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of parsed value\n * @returns A reusable `validateParse` function\n */\nexport declare function createValidateParse<T>(): (input: string) => IValidation<Primitive<T>>;\n/**\n * Creates a reusable {@link stringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createStringify(): never;\n/**\n * Creates a reusable {@link stringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `stringify` function\n */\nexport declare function createStringify<T>(): (input: T) => string;\n/**\n * Creates a reusable {@link assertStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertStringify(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertStringify` function\n */\nexport declare function createAssertStringify<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => string;\n/**\n * Creates a reusable {@link isStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsStringify(): never;\n/**\n * Creates a reusable {@link isStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `isStringify` function\n */\nexport declare function createIsStringify<T>(): (input: unknown) => string | null;\n/**\n * Creates a reusable {@link validateStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateStringify(): never;\n/**\n * Creates a reusable {@link validateStringify} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validateStringify` function\n */\nexport declare function createValidateStringify<T>(): (input: unknown) => IValidation<string>;\n",
   "node_modules/typia/lib/llm.d.ts": "import { ILlmApplication, ILlmController, ILlmSchema } from \"@samchon/openapi\";\n/**\n * > You must configure the generic argument `Class`.\n *\n * TypeScript functions to LLM function calling controller.\n *\n * Creates a controller of LLM (Large Language Model) function calling from a\n * TypeScript class or interface type containing the target functions to be\n * called by the LLM function calling feature. The returned controller contains\n * not only the {@link application} of\n * {@link ILlmFunction function calling schemas}, but also the\n * {@link ILlmController.execute executor} of the functions.\n *\n * If you put the returned {@link ILlmController} to the LLM provider like\n * [OpenAI (ChatGPT)](https://openai.com/), the LLM will automatically select\n * the proper function and fill its arguments from the conversation (maybe\n * chatting text) with user (human). And you can actually call the function by\n * using {@link ILlmController.execute} property. This is the concept of the LLM\n * function calling.\n *\n * Here is an example of using `typia.llm.controller()` function for AI agent\n * development of performing such AI function calling to mobile API classes\n * through this `typia` and external `@agentica` libraries.\n *\n * ```typescript\n * import { Agentica } from \"@agentica/core\";\n * import typia from \"typia\";\n *\n * const agentica = new Agentica({\n *   model: \"chatgpt\",\n *   vendor: {\n *     api: new OpenAI({ apiKey: \"********\" }),\n *     model: \"gpt-4o-mini\",\n *   },\n *   controllers: [\n *     typia.llm.controller<ReactNativeFileSystem, \"chatgpt\">(\n *       \"filesystem\",\n *       new ReactNativeFileSystem(),\n *     ),\n *     typia.llm.controller<ReactNativeGallery, \"chatgpt\">(\n *       \"gallery\",\n *       new ReactNativeGallery(),\n *     ),\n *   ],\n * });\n * await agentica.conversate(\n *   \"Organize photo collection and sort them into appropriate folders.\",\n * );\n * ```\n *\n * Here is the list of available `Model` types with their corresponding LLM\n * schema. Reading the following list, and determine the `Model` type\n * considering the characteristics of the target LLM provider.\n *\n * - LLM provider schemas\n *\n *   - `chatgpt`:\n *       [`IChatGptSchema`](https://samchon.github.io/openapi/api/types/IChatGptSchema-1.html)\n *   - `claude`:\n *       [`IClaudeSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `deepseek`:\n *       [`IDeepSeekSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `gemini`:\n *       [`IGeminiSchema`](https://samchon.github.io/openapi/api/types/IGeminiSchema-1.html)\n *   - `llama`:\n *       [`ILlamaSchema`](https://samchon.github.io/openapi/api/types/ILlamaSchema-1.html)\n * - Middle layer schemas\n *\n *   - `3.0`: [`ILlmSchemaV3`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3-1.html)\n *   - `3.1`: [`ILlmSchemaV3_1`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3_1-1.html)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Class Target class or interface type collecting the functions to\n *   call\n * @template Model LLM schema model\n * @template Config Configuration of LLM schema composition\n * @param name Identifier name of the controller\n * @param execute Executor instance\n * @param options Options for the LLM application construction\n * @returns Controller of LLM function calling\n * @reference https://wrtnlabs.io/agentica/docs/core/controller/typescript/\n */\nexport declare function controller(name: string, execute: object, options?: Partial<Pick<ILlmApplication.IOptions<any, any>, \"separate\" | \"validate\">>): never;\n/**\n * TypeScript functions to LLM function calling controller.\n *\n * Creates a controller of LLM (Large Language Model) function calling from a\n * TypeScript class or interface type containing the target functions to be\n * called by the LLM function calling feature. The returned controller contains\n * not only the {@link application} of\n * {@link ILlmFunction function calling schemas}, but also the\n * {@link ILlmController.execute executor} of the functions.\n *\n * If you put the returned {@link ILlmController} to the LLM provider like\n * [OpenAI (ChatGPT)](https://openai.com/), the LLM will automatically select\n * the proper function and fill its arguments from the conversation (maybe\n * chatting text) with user (human). And you can actually call the function by\n * using {@link ILlmController.execute} property. This is the concept of the LLM\n * function calling.\n *\n * Here is an example of using `typia.llm.controller()` function for AI agent\n * development of performing such AI function calling to mobile API classes\n * through this `typia` and external `@agentica` libraries.\n *\n * ```typescript\n * import { Agentica } from \"@agentica/core\";\n * import typia from \"typia\";\n *\n * const agentica = new Agentica({\n *   model: \"chatgpt\",\n *   vendor: {\n *     api: new OpenAI({ apiKey: \"********\" }),\n *     model: \"gpt-4o-mini\",\n *   },\n *   controllers: [\n *     typia.llm.controller<ReactNativeFileSystem, \"chatgpt\">(\n *       \"filesystem\",\n *       new ReactNativeFileSystem(),\n *     ),\n *     typia.llm.controller<ReactNativeGallery, \"chatgpt\">(\n *       \"gallery\",\n *       new ReactNativeGallery(),\n *     ),\n *   ],\n * });\n * await agentica.conversate(\n *   \"Organize photo collection and sort them into appropriate folders.\",\n * );\n * ```\n *\n * Here is the list of available `Model` types with their corresponding LLM\n * schema. Reading the following list, and determine the `Model` type\n * considering the characteristics of the target LLM provider.\n *\n * - LLM provider schemas\n *\n *   - `chatgpt`:\n *       [`IChatGptSchema`](https://samchon.github.io/openapi/api/types/IChatGptSchema-1.html)\n *   - `claude`:\n *       [`IClaudeSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `deepseek`:\n *       [`IDeepSeekSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `gemini`:\n *       [`IGeminiSchema`](https://samchon.github.io/openapi/api/types/IGeminiSchema-1.html)\n *   - `llama`:\n *       [`ILlamaSchema`](https://samchon.github.io/openapi/api/types/ILlamaSchema-1.html)\n * - Middle layer schemas\n *\n *   - `3.0`: [`ILlmSchemaV3`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3-1.html)\n *   - `3.1`: [`ILlmSchemaV3_1`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3_1-1.html)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Class Target class or interface type collecting the functions to\n *   call\n * @template Model LLM schema model\n * @template Config Configuration of LLM schema composition\n * @param name Identifier name of the controller\n * @param execute Executor instance\n * @param options Options for the LLM application construction\n * @returns Controller of LLM function calling\n * @reference https://wrtnlabs.io/agentica/docs/core/controller/typescript/\n */\nexport declare function controller<Class extends Record<string, any>, Model extends ILlmSchema.Model, Config extends Partial<ILlmSchema.ModelConfig[Model] & {\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}> = {}>(name: string, execute: Class, options?: Partial<Pick<ILlmApplication.IOptions<Model, Class>, \"separate\" | \"validate\">>): ILlmController<Model>;\n/**\n * > You must configure the generic argument `Class`.\n *\n * TypeScript functions to LLM function calling application.\n *\n * Creates an application of LLM (Large Language Model) function calling\n * application from a TypeScript class or interface type containing the target\n * functions to be called by the LLM function calling feature.\n *\n * If you put the returned {@link ILlmApplication.functions} objects to the LLM\n * provider like [OpenAI (ChatGPT)](https://openai.com/), the LLM will\n * automatically select the proper function and fill its arguments from the\n * conversation (maybe chatting text) with user (human). This is the concept of\n * the LLM function calling.\n *\n * By the way, there can be some parameters (or their nested properties) which\n * must be composed by human, not by LLM. File uploading feature or some\n * sensitive information like security keys (password) are the examples. In that\n * case, you can separate the function parameters to both LLM and human sides by\n * configuring the {@link ILlmApplication.IOptions.separate} property. The\n * separated parameters are assigned to the {@link ILlmFunction.separated}\n * property.\n *\n * For reference, the actual function call execution is not by LLM, but by you.\n * When the LLM selects the proper function and fills the arguments, you just\n * call the function with the LLM prepared arguments. And then informs the\n * return value to the LLM by system prompt. The LLM will continue the next\n * conversation based on the return value.\n *\n * Additionally, if you've configured {@link ILlmApplication.IOptions.separate},\n * so that the parameters are separated to human and LLM sides, you can merge\n * these human and LLM sides' parameters into one through\n * {@link HttpLlm.mergeParameters} before the actual LLM function call\n * execution.\n *\n * Here is the list of available `Model` types with their corresponding LLM\n * schema. Reading the following list, and determine the `Model` type\n * considering the characteristics of the target LLM provider.\n *\n * - LLM provider schemas\n *\n *   - `chatgpt`:\n *       [`IChatGptSchema`](https://github.com/samchon/openapi/blob/master/src/structures/IChatGptSchema.ts)\n *   - `claude`:\n *       [`IClaudeSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `deepseek`:\n *       [`IDeepSeekSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `gemini`:\n *       [`IGeminiSchema`](https://samchon.github.io/openapi/api/types/IGeminiSchema-1.html)\n *   - `llama`:\n *       [`ILlamaSchema`](https://samchon.github.io/openapi/api/types/ILlamaSchema-1.html)\n * - Middle layer schemas\n *\n *   - `3.0`: [`ILlmSchemaV3`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3-1.html)\n *   - `3.1`: [`ILlmSchemaV3_1`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3_1-1.html)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Class Target class or interface type collecting the functions to\n *   call\n * @template Model LLM schema model\n * @template Config Configuration of LLM schema composition\n * @param options Options for the LLM application construction\n * @returns Application of LLM function calling schemas\n * @reference https://platform.openai.com/docs/guides/function-calling\n */\nexport declare function application(options?: Partial<Pick<ILlmApplication.IOptions<any, any>, \"separate\" | \"validate\">>): never;\n/**\n * TypeScript functions to LLM function calling application.\n *\n * Creates an application of LLM (Large Language Model) function calling\n * application from a TypeScript class or interface type containing the target\n * functions to be called by the LLM function calling feature.\n *\n * If you put the returned {@link ILlmApplication.functions} objects to the LLM\n * provider like [OpenAI (ChatGPT)](https://openai.com/), the LLM will\n * automatically select the proper function and fill its arguments from the\n * conversation (maybe chatting text) with user (human). This is the concept of\n * the LLM function calling.\n *\n * By the way, there can be some parameters (or their nested properties) which\n * must be composed by human, not by LLM. File uploading feature or some\n * sensitive information like security keys (password) are the examples. In that\n * case, you can separate the function parameters to both LLM and human sides by\n * configuring the {@link ILlmApplication.IOptions.separate} property. The\n * separated parameters are assigned to the {@link ILlmFunction.separated}\n * property.\n *\n * For reference, the actual function call execution is not by LLM, but by you.\n * When the LLM selects the proper function and fills the arguments, you just\n * call the function with the LLM prepared arguments. And then informs the\n * return value to the LLM by system prompt. The LLM will continue the next\n * conversation based on the return value.\n *\n * Additionally, if you've configured {@link ILlmApplication.IOptions.separate},\n * so that the parameters are separated to human and LLM sides, you can merge\n * these human and LLM sides' parameters into one through\n * {@link HttpLlm.mergeParameters} before the actual LLM function call\n * execution.\n *\n * Here is the list of available `Model` types with their corresponding LLM\n * schema. Reading the following list, and determine the `Model` type\n * considering the characteristics of the target LLM provider.\n *\n * - LLM provider schemas\n *\n *   - `chatgpt`:\n *       [`IChatGptSchema`](https://github.com/samchon/openapi/blob/master/src/structures/IChatGptSchema.ts)\n *   - `claude`:\n *       [`IClaudeSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `deepseek`:\n *       [`IDeepSeekSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `gemini`:\n *       [`IGeminiSchema`](https://samchon.github.io/openapi/api/types/IGeminiSchema-1.html)\n *   - `llama`:\n *       [`ILlamaSchema`](https://samchon.github.io/openapi/api/types/ILlamaSchema-1.html)\n * - Middle layer schemas\n *\n *   - `3.0`: [`ILlmSchemaV3`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3-1.html)\n *   - `3.1`: [`ILlmSchemaV3_1`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3_1-1.html)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Class Target class or interface type collecting the functions to\n *   call\n * @template Model LLM schema model\n * @template Config Configuration of LLM schema composition\n * @param options Options for the LLM application construction\n * @returns Application of LLM function calling schemas\n * @reference https://platform.openai.com/docs/guides/function-calling\n */\nexport declare function application<Class extends Record<string, any>, Model extends ILlmSchema.Model, Config extends Partial<{\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} & ILlmSchema.ModelConfig[Model]> = {}>(options?: Partial<Pick<ILlmApplication.IOptions<Model, Class>, \"separate\" | \"validate\">>): ILlmApplication<Model, Class>;\n/**\n * > You must configure the generic argument `Parameters`.\n *\n * TypeScript parameters to LLM parameters schema.\n *\n * Creates an LLM (Large Language Model) parameters schema, a type metadata that\n * is used in the [LLM function\n * calling](https://platform.openai.com/docs/guides/function-calling) and [LLM\n * structured\n * outputs](https://platform.openai.com/docs/guides/structured-outputs), from a\n * TypeScript parameters type.\n *\n * For references, LLM identifies only keyworded arguments, not positional\n * arguments. Therefore, the TypeScript parameters type must be an object type,\n * and its properties must be static. If dynamic properties are, it will be\n * compilation error.\n *\n * Also, such parameters type can be utilized not only for the LLM function\n * calling, but also for the LLM structured outputs. The LLM structured outputs\n * is a feature that LLM (Large Language Model) can generate a structured\n * output, not only a plain text, by filling the parameters from the\n * conversation (maybe chatting text) with user (human).\n *\n * Here is the list of available `Model` types with their corresponding LLM\n * schema. Reading the following list, and determine the `Model` type\n * considering the characteristics of the target LLM provider.\n *\n * - LLM provider schemas\n *\n *   - `chatgpt`:\n *       [`IChatGptSchema`](https://github.com/samchon/openapi/blob/master/src/structures/IChatGptSchema.ts)\n *   - `claude`:\n *       [`IClaudeSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `deepseek`:\n *       [`IDeepSeekSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `gemini`:\n *       [`IGeminiSchema`](https://samchon.github.io/openapi/api/types/IGeminiSchema-1.html)\n *   - `llama`:\n *       [`ILlamaSchema`](https://samchon.github.io/openapi/api/types/ILlamaSchema-1.html)\n * - Middle layer schemas\n *\n *   - `3.0`: [`ILlmSchemaV3`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3-1.html)\n *   - `3.1`: [`ILlmSchemaV3_1`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3_1-1.html)\n *\n * @template Parameters Target parameters type\n * @template Model LLM schema model\n * @template Config Configuration of LLM schema composition\n * @returns LLM parameters schema\n * @reference https://platform.openai.com/docs/guides/function-calling\n * @reference https://platform.openai.com/docs/guides/structured-outputs\n */\nexport declare function parameters(): never;\n/**\n * TypeScript parameters to LLM parameters schema.\n *\n * Creates an LLM (Large Language Model) parameters schema, a type metadata that\n * is used in the [LLM function\n * calling](https://platform.openai.com/docs/guides/function-calling) and [LLM\n * structured\n * outputs](https://platform.openai.com/docs/guides/structured-outputs), from a\n * TypeScript parameters type.\n *\n * For references, LLM identifies only keyworded arguments, not positional\n * arguments. Therefore, the TypeScript parameters type must be an object type,\n * and its properties must be static. If dynamic properties are, it will be\n * compilation error.\n *\n * Also, such parameters type can be utilized not only for the LLM function\n * calling, but also for the LLM structured outputs. The LLM structured outputs\n * is a feature that LLM (Large Language Model) can generate a structured\n * output, not only a plain text, by filling the parameters from the\n * conversation (maybe chatting text) with user (human).\n *\n * Here is the list of available `Model` types with their corresponding LLM\n * schema. Reading the following list, and determine the `Model` type\n * considering the characteristics of the target LLM provider.\n *\n * - LLM provider schemas\n *\n *   - `chatgpt`:\n *       [`IChatGptSchema`](https://github.com/samchon/openapi/blob/master/src/structures/IChatGptSchema.ts)\n *   - `claude`:\n *       [`IClaudeSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `deepseek`:\n *       [`IDeepSeekSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `gemini`:\n *       [`IGeminiSchema`](https://samchon.github.io/openapi/api/types/IGeminiSchema-1.html)\n *   - `llama`:\n *       [`ILlamaSchema`](https://samchon.github.io/openapi/api/types/ILlamaSchema-1.html)\n * - Middle layer schemas\n *\n *   - `3.0`: [`ILlmSchemaV3`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3-1.html)\n *   - `3.1`: [`ILlmSchemaV3_1`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3_1-1.html)\n *\n * @template Parameters Target parameters type\n * @template Model LLM schema model\n * @template Config Configuration of LLM schema composition\n * @returns LLM parameters schema\n * @reference https://platform.openai.com/docs/guides/function-calling\n * @reference https://platform.openai.com/docs/guides/structured-outputs\n */\nexport declare function parameters<Parameters extends Record<string, any>, Model extends ILlmSchema.Model, Config extends Partial<ILlmSchema.ModelConfig[Model]> = {}>(): ILlmSchema.ModelParameters[Model];\n/**\n * > You must configure the generic argument `T`.\n *\n * TypeScript type to LLM type schema.\n *\n * Creates an LLM (Large Language Model) type schema, a type metadata that is\n * used in the [LLM function calling](@reference\n * https://platform.openai.com/docs/guides/function-calling), from a TypeScript\n * type.\n *\n * The returned {@link ILlmSchema} type will be specified by the `Model`\n * argument, and here is the list of available `Model` types with their\n * corresponding LLM schema. Reading the following list, and determine the\n * `Model` type considering the characteristics of the target LLM provider.\n *\n * - LLM provider schemas\n *\n *   - `chatgpt`:\n *       [`IChatGptSchema`](https://github.com/samchon/openapi/blob/master/src/structures/IChatGptSchema.ts)\n *   - `claude`:\n *       [`IClaudeSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `deepseek`:\n *       [`IDeepSeekSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `gemini`:\n *       [`IGeminiSchema`](https://samchon.github.io/openapi/api/types/IGeminiSchema-1.html)\n *   - `llama`:\n *       [`ILlamaSchema`](https://samchon.github.io/openapi/api/types/ILlamaSchema-1.html)\n * - Middle layer schemas\n *\n *   - `3.0`: [`ILlmSchemaV3`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3-1.html)\n *   - `3.1`: [`ILlmSchemaV3_1`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3_1-1.html)\n *\n * If you actually want to perform the LLM function calling with TypeScript\n * functions, you can do it with the {@link application} function. Otherwise you\n * hope to perform the structured output, {@link parameters} function is better.\n * Let's enjoy the LLM function calling and structured output with the native\n * TypeScript functions and types.\n *\n * > **What LLM function calling is?\n *\n * > LLM (Large Language Model) selects property function and fill the arguments,\n * > but actual function call execution is not by LLM, but by you.\n *\n * > In nowadays, most LLM (Large Language Model) like OpenAI are supporting\n * > \"function calling\" feature. The \"function calling\" means that LLM\n * > automatically selects a proper function and compose parameter values from the\n * > user's chatting text.\n *\n * > When LLM selects the proper function and its arguments, you just call the\n * > function with the arguments. And then informs the return value to the LLM by\n * > system prompt, LLM will continue the next conversation based on the return\n * > value.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @template Model LLM schema model\n * @template Config Configuration of LLM schema composition\n * @returns LLM schema\n * @reference https://platform.openai.com/docs/guides/function-calling\n * @reference https://platform.openai.com/docs/guides/structured-outputs\n */\nexport declare function schema(): never;\n/**\n * TypeScript type to LLM type schema.\n *\n * Creates an LLM (Large Language Model) type schema, a type metadata that is\n * used in the [LLM function calling](@reference\n * https://platform.openai.com/docs/guides/function-calling), from a TypeScript\n * type.\n *\n * The returned {@link ILlmSchema} type will be specified by the `Model`\n * argument, and here is the list of available `Model` types with their\n * corresponding LLM schema:\n *\n * - LLM provider schemas\n *\n *   - `chatgpt`:\n *       [`IChatGptSchema`](https://github.com/samchon/openapi/blob/master/src/structures/IChatGptSchema.ts)\n *   - `claude`:\n *       [`IClaudeSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `deepseek`:\n *       [`IDeepSeekSchema`](https://samchon.github.io/openapi/api/types/IClaudeSchema-1.html)\n *   - `gemini`:\n *       [`IGeminiSchema`](https://samchon.github.io/openapi/api/types/IGeminiSchema-1.html)\n *   - `llama`:\n *       [`ILlamaSchema`](https://samchon.github.io/openapi/api/types/ILlamaSchema-1.html)\n * - Middle layer schemas\n *\n *   - `3.0`: [`ILlmSchemaV3`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3-1.html)\n *   - `3.1`: [`ILlmSchemaV3_1`](https://samchon.github.io/openapi/api/types/ILlmSchemaV3_1-1.html)\n *\n * If you actually want to perform the LLM function calling with TypeScript\n * functions, you can do it with the {@link application} function. Otherwise you\n * hope to perform the structured output, {@link parameters} function is better.\n * Let's enjoy the LLM function calling and structured output with the native\n * TypeScript functions and types.\n *\n * > **What LLM function calling is?\n *\n * > LLM (Large Language Model) selects property function and fill the arguments,\n * > but actual function call execution is not by LLM, but by you.\n *\n * > In nowadays, most LLM (Large Language Model) like OpenAI are supporting\n * > \"function calling\" feature. The \"function calling\" means that LLM\n * > automatically selects a proper function and compose parameter values from the\n * > user's chatting text.\n *\n * > When LLM selects the proper function and its arguments, you just call the\n * > function with the arguments. And then informs the return value to the LLM by\n * > system prompt, LLM will continue the next conversation based on the return\n * > value.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @template Model LLM schema model\n * @template Config Configuration of LLM schema composition\n * @returns LLM schema\n * @reference https://platform.openai.com/docs/guides/function-calling\n * @reference https://platform.openai.com/docs/guides/structured-outputs\n */\nexport declare function schema<T, Model extends ILlmSchema.Model, Config extends Partial<ILlmSchema.ModelConfig[Model]> = {}>(...$defs: Extract<ILlmSchema.ModelSchema[Model], {\n    $ref: string;\n}> extends never ? [] : [Record<string, ILlmSchema.ModelSchema[Model]>]): ILlmSchema.ModelSchema[Model];\n",
   "node_modules/typia/lib/misc.d.ts": "import { Atomic } from \"./typings/Atomic\";\nimport { IValidation } from \"./IValidation\";\nimport { Resolved } from \"./Resolved\";\nimport { TypeGuardError } from \"./TypeGuardError\";\n/**\n * > You must configure the generic argument `T`.\n *\n * Union literal type to array.\n *\n * Converts a union literal type to an array of its members.\n *\n * ```typescript\n * literals<\"A\" | \"B\" | 1>; // [\"A\", \"B\", 1]\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Union literal type\n * @returns Array of union literal type's members\n */\nexport declare function literals(): never;\n/**\n * Union literal type to array.\n *\n * Converts a union literal type to an array of its members.\n *\n * ```typescript\n * literals<\"A\" | \"B\" | 1>; // [\"A\", \"B\", 1]\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Union literal type\n * @returns Array of union literal type's members\n */\nexport declare function literals<T extends Atomic.Type | null>(): T[];\n/**\n * Clone data.\n *\n * Clones an instance following type `T`. If the target _input_ value or its\n * member variable contains a class instance having methods, those methods would\n * not be cloned.\n *\n * For reference, this `typia.misc.clone()` function does not validate the input\n * value type. It just believes that the input value is following the type `T`.\n * Therefore, if you can't ensure the input value type, it would be better to\n * call {@link assertClone} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be cloned\n * @returns Cloned data\n */\nexport declare function clone<T>(input: T): Resolved<T>;\n/**\n * Clone data with type assertion.\n *\n * Clones an instance following type `T`, with type assertion. If the target\n * `input` value or its member variable contains a class instance having\n * methods, those methods would not be cloned.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * throws an {@link TypeGuardError} or custom error generated by _errorFactory_.\n * Otherwise, there's no problem on the `input` value, cloned data would be\n * returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be cloned\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Cloned data\n */\nexport declare function assertClone<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): Resolved<T>;\n/**\n * Clone data with type assertion.\n *\n * Clones an instance following type `T`, with type assertion. If the target\n * `input` value or its member variable contains a class instance having\n * methods, those methods would not be cloned.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * throws an {@link TypeGuardError} or custom error generated by _errorFactory_.\n * Otherwise, there's no problem on the `input` value, cloned data would be\n * returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be cloned\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Cloned data\n */\nexport declare function assertClone<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): Resolved<T>;\n/**\n * Clone data with type checking.\n *\n * Clones an instance following type `T`, with type checking. If the target\n * `input` value or its member variable contains a class instance having\n * methods, those methods would not be cloned.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns `null` value instead. Otherwise, there's no problem on the `input`\n * value, cloned data would be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be cloned\n * @returns Cloned data when exact type, otherwise null\n */\nexport declare function isClone<T>(input: T): Resolved<T> | null;\n/**\n * Clone data with type checking.\n *\n * Clones an instance following type `T`, with type checking. If the target\n * `input` value or its member variable contains a class instance having\n * methods, those methods would not be cloned.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns `null` value instead. Otherwise, there's no problem on the `input`\n * value, cloned data would be returned.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be cloned\n * @returns Cloned data when exact type, otherwise null\n */\nexport declare function isClone<T>(input: unknown): Resolved<T> | null;\n/**\n * Clone data with detailed type validation.\n *\n * Clones an instance following type `T`, with detailed type validation. If the\n * target `input` value or its member variable contains a class instance having\n * methods, those methods would not be cloned.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns {@link IValidation.Failure} value. Otherwise, there's no problem on\n * the `input` value, cloned data would be stored in `data` property of the\n * output {@link IValidation.Success} instance.\n *\n * @template T Type of the input value\n * @param input A value to be cloned\n * @returns Validation result with cloned value\n */\nexport declare function validateClone<T>(input: T): IValidation<Resolved<T>>;\n/**\n * Clone data with detailed type validation.\n *\n * Clones an instance following type `T`, with detailed type validation. If the\n * target `input` value or its member variable contains a class instance having\n * methods, those methods would not be cloned.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns {@link IValidation.Failure} value. Otherwise, there's no problem on\n * the `input` value, cloned data would be stored in `data` property of the\n * output {@link IValidation.Success} instance.\n *\n * @template T Type of the input value\n * @param input A value to be cloned\n * @returns Validation result with cloned value\n */\nexport declare function validateClone<T>(input: unknown): IValidation<Resolved<T>>;\n/**\n * Prune, erase superfluous properties.\n *\n * Remove all superfluous properties from the `input` object, even including\n * nested objects. Note that, as all superfluous properties would be deleted,\n * you never can read those superfluous properties after calling this `prune()`\n * function.\n *\n * For reference, this `typia.misc.prune()` function does not validate the input\n * value type. It just believes that the input value is following the type `T`.\n * Therefore, if you can't ensure the input value type, it would better to call\n * one of below functions instead.\n *\n * - {@link assertPrune}\n * - {@link isPrune}\n * - {@link validatePrune}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target instance to prune\n */\nexport declare function prune<T extends object>(input: T): void;\n/**\n * Prune, erase superfluous properties, with type assertion.\n *\n * `typia.misc.assertPrune()` is a combination function of {@link assert} and\n * {@link prune}. Therefore, it removes all superfluous properties from the\n * `input` object including nested objects, with type assertion.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * throws an {@link TypeGuardError} or custom error generated by _errorFactory_.\n * Otherwise, there's no problem on the `input` value, its all superfluous\n * properties would be removed, including nested objects.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target instance to assert and prune\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n */\nexport declare function assertPrune<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Prune, erase superfluous properties, with type assertion.\n *\n * `typia.misc.assertPrune()` is a combination function of {@link assert} and\n * {@link prune}. Therefore, it removes all superfluous properties from the\n * `input` object including nested objects, with type assertion.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * throws an {@link TypeGuardError} or custom error generated by _errorFactory_.\n * Otherwise, there's no problem on the `input` value, its all superfluous\n * properties would be removed, including nested objects.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target instance to assert and prune\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n */\nexport declare function assertPrune<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Prune, erase superfluous properties, with type checking.\n *\n * `typia.misc.isPrune()` is a combination function of {@link is} and\n * {@link prune}. Therefore, it removes all superfluous properties from the\n * `input` object including nested objects, with type checking.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns `false` value. Otherwise, there's no problem on the `input` value, it\n * returns `true` after removing all superfluous properties, including nested\n * objects.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target instance to check and prune\n * @returns Whether the parametric value is following the type `T` or not\n */\nexport declare function isPrune<T>(input: T): input is T;\n/**\n * Prune, erase superfluous properties, with type checking.\n *\n * `typia.misc.isPrune()` is a combination function of {@link is} and\n * {@link prune}. Therefore, it removes all superfluous properties from the\n * `input` object including nested objects, with type checking.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns `false` value. Otherwise, there's no problem on the `input` value, it\n * returns `true` after removing all superfluous properties, including nested\n * objects.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target instance to check and prune\n * @returns Whether the parametric value is following the type `T` or not\n */\nexport declare function isPrune<T>(input: unknown): input is T;\n/**\n * Prune, erase superfluous properties, with type validation.\n *\n * `typia.misc.validatePrune()` is a combination function of {@link validate} and\n * {@link prune}. Therefore, it removes all superfluous properties from the\n * `input` object including nested objects, with type validation.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns {@link IValidation.IFailure} value with detailed error reasons.\n * Otherwise, there's no problem on the `input` value, it returns\n * {@link IValidation.ISuccess} value after removing all superfluous properties,\n * including nested objects.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target instance to validate and prune\n * @returns Validation result\n */\nexport declare function validatePrune<T>(input: T): IValidation<T>;\n/**\n * Prune, erase superfluous properties, with type validation.\n *\n * `typia.misc.validatePrune()` is a combination function of {@link validate} and\n * {@link prune}. Therefore, it removes all superfluous properties from the\n * `input` object including nested objects, with type validation.\n *\n * In such reason, when `input` value is not matched with the type `T`, it\n * returns {@link IValidation.IFailure} value with detailed error reasons.\n * Otherwise, there's no problem on the `input` value, it returns\n * {@link IValidation.ISuccess} value after removing all superfluous properties,\n * including nested objects.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target instance to validate and prune\n * @returns Validation result\n */\nexport declare function validatePrune<T>(input: unknown): IValidation<T>;\n/**\n * Creates a reusable {@link clone} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createClone(): never;\n/**\n * Creates a reusable {@link clone} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `clone` function\n */\nexport declare function createClone<T>(): (input: T) => Resolved<T>;\n/**\n * Creates a reusable {@link assertClone} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertClone(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertClone} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `clone` function\n */\nexport declare function createAssertClone<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => Resolved<T>;\n/**\n * Creates a reusable {@link isClone} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsClone(): never;\n/**\n * Creates a reusable {@link isClone} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `clone` function\n */\nexport declare function createIsClone<T>(): (input: unknown) => Resolved<T> | null;\n/**\n * Creates a reusable {@link validateClone} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateClone(): never;\n/**\n * Creates a reusable {@link validateClone} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `clone` function\n */\nexport declare function createValidateClone<T>(): (input: unknown) => IValidation<Resolved<T>>;\n/**\n * Creates a reusable {@link prune} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createPrune(): never;\n/**\n * Creates a reusable {@link prune} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `prune` function\n */\nexport declare function createPrune<T extends object>(): (input: T) => void;\n/**\n * Creates a reusable {@link assertPrune} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertPrune(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertPrune} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `isPrune` function\n */\nexport declare function createAssertPrune<T extends object>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: T) => T;\n/**\n * Creates a reusable {@link isPrune} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsPrune(): never;\n/**\n * Creates a reusable {@link isPrune} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `isPrune` function\n */\nexport declare function createIsPrune<T extends object>(): (input: T) => input is T;\n/**\n * Creates a reusable {@link validatePrune} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidatePrune(): never;\n/**\n * Creates a reusable {@link validatePrune} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validatePrune` function\n */\nexport declare function createValidatePrune<T extends object>(): (input: T) => IValidation<T>;\n",
-  "node_modules/typia/lib/module.d.ts": "import { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { AssertionGuard } from \"./AssertionGuard\";\nimport { IRandomGenerator } from \"./IRandomGenerator\";\nimport { IValidation } from \"./IValidation\";\nimport { Resolved } from \"./Resolved\";\nimport { TypeGuardError } from \"./TypeGuardError\";\nexport * as functional from \"./functional\";\nexport * as http from \"./http\";\nexport * as llm from \"./llm\";\nexport * as json from \"./json\";\nexport * as misc from \"./misc\";\nexport * as notations from \"./notations\";\nexport * as protobuf from \"./protobuf\";\nexport * as reflect from \"./reflect\";\nexport * as tags from \"./tags\";\nexport * from \"./schemas/metadata/IJsDocTagInfo\";\nexport * from \"./schemas/json/IJsonApplication\";\nexport * from \"./schemas/json/IJsonSchemaCollection\";\nexport * from \"./schemas/json/IJsonSchemaUnit\";\nexport * from \"./AssertionGuard\";\nexport * from \"./IRandomGenerator\";\nexport * from \"./IValidation\";\nexport * from \"./TypeGuardError\";\nexport * from \"./Primitive\";\nexport * from \"./Resolved\";\nexport * from \"./CamelCase\";\nexport * from \"./PascalCase\";\nexport * from \"./SnakeCase\";\nexport * from \"./IReadableURLSearchParams\";\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with a\n * detailed reason, if the parametric value is not following the type `T`.\n * Otherwise, if the value is following the type `T`, the input parameter will\n * be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link is} function\n * instead. Otherwise, if you want to know all the errors, {@link validate} is\n * the way to go. Also, if you want to automatically cast the parametric value\n * to the type `T` when there is no problem (perform the assertion guard of\n * type).\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link assertEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assert<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with a\n * detailed reason, if the parametric value is not following the type `T`.\n * Otherwise, if the value is following the type `T`, the input parameter will\n * be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link is} function\n * instead. Otherwise, if you want to know all the errors, {@link validate} is\n * the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link assertEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assert<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Assertion guard of a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with a\n * detailed reason, if the parametric value is not following the type `T`.\n * Otherwise, if the value is following the type `T`, nothing will be returned,\n * but the input value will be automatically casted to the type `T`. This is the\n * concept of \"Assertion Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link is} function\n * instead. Otherwise, if you want to know all the errors, {@link validate} is\n * the way to go. Also, if you want to return the parametric value when there is\n * no problem, you can use {@link assert} function instead.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link assertGuardEquals}\n * function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertGuard<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Assertion guard of a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with a\n * detailed reason, if the parametric value is not following the type `T`.\n * Otherwise, if the value is following the type `T`, nothing will be returned,\n * but the input value will be automatically casted to the type `T`. This is the\n * concept of \"Assertion Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link is} function\n * instead. Otherwise, if you want to know all the errors, {@link validate} is\n * the way to go. Also, if you want to return the parametric value when there is\n * no problem, you can use {@link assert} function instead.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link assertGuardEquals}\n * function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertGuard<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Tests a value type.\n *\n * Tests a parametric value type and returns whether it's following the type `T`\n * or not. If the parametric value is matched with the type `T`, `true` value\n * will be returned. Otherwise, if the parametric value is not following the\n * type `T`, `false` value will be returned.\n *\n * If what you want is not just knowing whether the parametric value is\n * following the type `T` or not, but throwing an exception with a detailed\n * reason, you can choose {@link assert} function instead. Also, if you want to\n * know all the errors with detailed reasons, {@link validate} function will be\n * useful.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link equals} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be tested\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Whether the parametric value is following the type `T` or not\n */\nexport declare function is<T>(input: T): input is T;\n/**\n * Tests a value type.\n *\n * Tests a parametric value type and returns whether it's following the type `T`\n * or not. If the parametric value is matched with the type `T`, `true` value\n * will be returned. Otherwise, if the parametric value is not following the\n * type `T`, `false` value will be returned.\n *\n * If what you want is not just knowing whether the parametric value is\n * following the type `T` or not, but throwing an exception with a detailed\n * reason, you can choose {@link assert} function instead. Also, if you want to\n * know all the errors with detailed reasons, {@link validate} function will be\n * useful.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link equals} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be tested\n * @returns Whether the parametric value is following the type `T` or not\n */\nexport declare function is<T>(input: unknown): input is T;\n/**\n * Validates a value type.\n *\n * Validates a parametric value type and archives all the type errors into an\n * {@link IValidation.errors} array, if the parametric value is not following the\n * type `T`. Of course, if the parametric value is following the type `T`, the\n * {@link IValidation.errors} array will be empty and {@link IValidation.success}\n * will have the `true` value.\n *\n * If what you want is not finding all the errors, but asserting the parametric\n * value type with exception throwing, you can choose {@link assert} function\n * instead. Otherwise, if you just want to know whether the parametric value is\n * matched with the type `T`, {@link is} function is the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link validateEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be validated\n * @returns Validation result\n */\nexport declare function validate<T>(input: T): IValidation<T>;\n/**\n * Validates a value type.\n *\n * Validates a parametric value type and archives all the type errors into an\n * {@link IValidation.errors} array, if the parametric value is not following the\n * type `T`. Of course, if the parametric value is following the type `T`, the\n * {@link IValidation.errors} array will be empty and {@link IValidation.success}\n * will have the `true` value.\n *\n * If what you want is not finding all the errors, but asserting the parametric\n * value type with exception throwing, you can choose {@link assert} function\n * instead. Otherwise, if you just want to know whether the parametric value is\n * matched with the type `T`, {@link is} function is the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link validateEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be validated\n * @returns Validation result\n */\nexport declare function validate<T>(input: unknown): IValidation<T>;\n/**\n * Asserts equality between a value and its type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with\n * detailed reason, if the parametric value is not following the type `T` or\n * some superfluous property that is not listed on the type `T` has been found.\n * Otherwise, the value is following the type `T` without any superfluous\n * property, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link equals}\n * function instead. Otherwise, if you want to know all the errors,\n * {@link validateEquals} is the way to go.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link assert} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertEquals<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Asserts equality between a value and its type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with\n * detailed reason, if the parametric value is not following the type `T` or\n * some superfluous property that is not listed on the type `T` has been found.\n * Otherwise, the value is following the type `T` without any superfluous\n * property, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link equals}\n * function instead. Otherwise, if you want to know all the errors,\n * {@link validateEquals} is the way to go.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link assert} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertEquals<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Assertion guard of a type with equality.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with\n * detailed reason, if the parametric value is not following the type `T` or\n * some superfluous property that is not listed on the type `T` has been found.\n *\n * Otherwise, the value is following the type `T` without any superfluous\n * property, nothing will be returned, but the input value would be\n * automatically casted to the type `T`. This is the concept of \"Assertion\n * Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link equals}\n * function instead. Otherwise, if you want to know all the errors,\n * {@link validateEquals} is the way to go. Also, if you want to returns the\n * parametric value when no problem, you can use {@link assert} function\n * instead.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertEquals} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertGuardEquals<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Assertion guard of a type with equality.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with\n * detailed reason, if the parametric value is not following the type `T` or\n * some superfluous property that is not listed on the type `T` has been found.\n *\n * Otherwise, the value is following the type `T` without any superfluous\n * property, nothing will be returned, but the input value would be\n * automatically casted to the type `T`. This is the concept of \"Assertion\n * Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link equals}\n * function instead. Otherwise, if you want to know all the errors,\n * {@link validateEquals} is the way to go. Also, if you want to returns the\n * parametric value when no problem, you can use {@link assertEquals} function\n * instead.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertGuard} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertGuardEquals<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Tests equality between a value and its type.\n *\n * Tests a parametric value type and returns whether it's equivalent to the type\n * `T` or not. If the parametric value is matched with the type `T` and there's\n * not any superfluous property that is not listed on the type `T`, `true` value\n * will be returned. Otherwise, if the parametric value is not following the\n * type `T` or some superfluous property exists, `false` value will be\n * returned.\n *\n * If what you want is not just knowing whether the parametric value is\n * following the type `T` or not, but throwing an exception with a detailed\n * reason, you can choose {@link assertEquals} function instead. Also, if you\n * want to know all the errors with detailed reasons, {@link validateEquals}\n * function will be useful.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link is} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be tested\n * @returns Whether the parametric value is equivalent to the type `T` or not\n */\nexport declare function equals<T>(input: T): input is T;\n/**\n * Tests equality between a value and its type.\n *\n * Tests a parametric value type and returns whether it's equivalent to the type\n * `T` or not. If the parametric value is matched with the type `T` and there's\n * not any superfluous property that is not listed on the type `T`, `true` value\n * will be returned. Otherwise, if the parametric value is not following the\n * type `T` or some superfluous property exists, `false` value will be\n * returned.\n *\n * If what you want is not just knowing whether the parametric value is\n * following the type `T` or not, but throwing an exception with a detailed\n * reason, you can choose {@link assertEquals} function instead. Also, if you\n * want to know all the errors with detailed reasons, {@link validateEquals}\n * function will be useful.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link is} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be tested\n * @returns Whether the parametric value is equivalent to the type `T` or not\n */\nexport declare function equals<T>(input: unknown): input is T;\n/**\n * Validates equality between a value and its type.\n *\n * Validates a parametric value type and archives all the type errors into an\n * {@link IValidation.errors} array, if the parametric value is not following the\n * type `T` or some superfluous property that is not listed on the type `T` has\n * been found. Of course, if the parametric value is following the type `T` and\n * no superfluous property exists, the {@link IValidation.errors} array would be\n * empty and {@link IValidation.success} would have the `true` value.\n *\n * If what you want is not finding all the error, but asserting the parametric\n * value type with exception throwing, you can choose {@link assert} function\n * instead. Otherwise, you just want to know whether the parametric value is\n * matched with the type `T`, {@link is} function is the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link validateEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Type Of the input value\n * @param input A value to be validated\n * @returns Validation result\n */\nexport declare function validateEquals<T>(input: T): IValidation<T>;\n/**\n * Validates equality between a value and its type.\n *\n * Validates a parametric value type and archives all the type errors into an\n * {@link IValidation.errors} array, if the parametric value is not following the\n * type `T` or some superfluous property that is not listed on the type `T` has\n * been found. Of course, if the parametric value is following the type `T` and\n * no superfluous property exists, the {@link IValidation.errors} array would be\n * empty and {@link IValidation.success} would have the `true` value.\n *\n * If what you want is not finding all the error, but asserting the parametric\n * value type with exception throwing, you can choose {@link assert} function\n * instead. Otherwise, you just want to know whether the parametric value is\n * matched with the type `T`, {@link is} function is the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link validateEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Type Of the input value\n * @param input A value to be validated\n * @returns Validation result\n */\nexport declare function validateEquals<T>(input: unknown): IValidation<T>;\n/**\n * > You must configure the generic argument `T`.\n *\n * Generate random data.\n *\n * Generates a random data following type the `T`.\n *\n * For reference, this `typia.random()` function generates only primitive type.\n * If there're some methods in the type `T` or its nested instances, those would\n * be ignored. Also, when the type `T` has a `toJSON()` method, its return type\n * will be generated instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of data to generate\n * @param generator Random data generator\n * @returns Randomly generated data\n */\nexport declare function random(generator?: Partial<IRandomGenerator>): never;\n/**\n * Generate random data.\n *\n * Generates a random data following type the `T`.\n *\n * For reference, this `typia.random()` function generates only primitive type.\n * If there're some methods in the type `T` or its nested instances, those would\n * be ignored. Also, when the type `T` has a `toJSON()` method, its return type\n * will be generated instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of data to generate\n * @param generator Random data generator\n * @returns Randomly generated data\n */\nexport declare function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;\n/**\n * Creates a reusable {@link assert} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssert(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assert} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assert` function\n */\nexport declare function createAssert<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => T;\n/**\n * Creates a reusable {@link assertGuard} function.\n *\n * Note that, you've to declare the variable type of the factory function caller\n * like below. If you don't declare the variable type, compilation error be\n * thrown. This is the special rule of the TypeScript compiler.\n *\n * ```typescript\n * // MUST DECLARE THE VARIABLE TYPE\n * const func: typia.AssertionGuard<number> = typia.createAssertGuard<number>();\n *\n * // IF NOT, COMPILATION ERROR BE OCCURRED\n * const func = typia.createAssertGuard<number>();\n * ```\n *\n * > _Assertions require every name in the call target to be declared with an_\n * > _explicit type annotation._\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertGuard(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertGuard} function.\n *\n * Note that, you've to declare the variable type of the factory function caller\n * like below. If you don't declare the variable type, compilation error be\n * thrown. This is the special rule of the TypeScript compiler.\n *\n * ```typescript\n * // MUST DECLARE THE VARIABLE TYPE\n * const func: typia.AssertionGuard<number> = typia.createAssertGuard<number>();\n *\n * // IF NOT, COMPILATION ERROR BE OCCURRED\n * const func = typia.createAssertGuard<number>();\n * ```\n *\n * > _Assertions require every name in the call target to be declared with an_\n * > _explicit type annotation._\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n */\nexport declare function createAssertGuard<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => AssertionGuard<T>;\n/**\n * Creates a reusable {@link is} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIs(): never;\n/**\n * Creates a reusable {@link is} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `is` function\n */\nexport declare function createIs<T>(): (input: unknown) => input is T;\n/**\n * Creates a reusable {@link validate} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidate(): never;\n/**\n * Creates a reusable {@link validate} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validate` function\n */\nexport declare function createValidate<T>(): ((input: unknown) => IValidation<T>) & StandardSchemaV1<unknown, T>;\n/**\n * Creates a reusable {@link assertEquals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertEquals(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertEquals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertEquals` function\n */\nexport declare function createAssertEquals<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => T;\n/**\n * Creates a reusable {@link assertGuardEquals} function.\n *\n * Note that, you've to declare the variable type of the factory function caller\n * like below. If you don't declare the variable type, compilation error be\n * thrown. This is the special rule of the TypeScript compiler.\n *\n * ```typescript\n * // MUST DECLARE THE VARIABLE TYPE\n * const func: typia.AssertionGuard<number> = typia.createAssertGuardEquals<number>();\n *\n * // IF NOT, COMPILATION ERROR BE OCCURRED\n * const func = typia.createAssertGuardEquals<number>();\n * ```\n *\n * > _Assertions require every name in the call target to be declared with an_\n * > _explicit type annotation._\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertGuardEquals(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertGuardEquals} function.\n *\n * Note that, you've to declare the variable type of the factory function caller\n * like below. If you don't declare the variable type, compilation error be\n * thrown. This is the special rule of the TypeScript compiler.\n *\n * ```typescript\n * // MUST DECLARE THE VARIABLE TYPE\n * const func: typia.AssertionGuard<number> = typia.createAssertGuardEquals<number>();\n *\n * // IF NOT, COMPILATION ERROR BE OCCURRED\n * const func = typia.createAssertGuardEquals<number>();\n * ```\n *\n * > _Assertions require every name in the call target to be declared with an_\n * > _explicit type annotation._\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n */\nexport declare function createAssertGuardEquals<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => AssertionGuard<T>;\n/**\n * Creates a reusable {@link equals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createEquals(): never;\n/**\n * Creates a reusable {@link equals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `equals` function\n */\nexport declare function createEquals<T>(): (input: unknown) => input is T;\n/**\n * Creates a reusable {@link validateEquals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateEquals(): never;\n/**\n * Creates a reusable {@link validateEquals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validateEquals` function\n */\nexport declare function createValidateEquals<T>(): ((input: unknown) => IValidation<T>) & StandardSchemaV1<unknown, T>;\n/**\n * Creates a reusable {@link random} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param generator Random data generator\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createRandom(generator?: Partial<IRandomGenerator>): never;\n/**\n * Creates a reusable {@link random} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param generator Random data generator\n * @returns A reusable `random` function\n */\nexport declare function createRandom<T>(generator?: Partial<IRandomGenerator>): () => Resolved<T>;\n",
+  "node_modules/typia/lib/module.d.ts": "import { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { AssertionGuard } from \"./AssertionGuard\";\nimport { IRandomGenerator } from \"./IRandomGenerator\";\nimport { IValidation } from \"./IValidation\";\nimport { Resolved } from \"./Resolved\";\nimport { TypeGuardError } from \"./TypeGuardError\";\nexport * as functional from \"./functional\";\nexport * as http from \"./http\";\nexport * as llm from \"./llm\";\nexport * as json from \"./json\";\nexport * as misc from \"./misc\";\nexport * as notations from \"./notations\";\nexport * as protobuf from \"./protobuf\";\nexport * as reflect from \"./reflect\";\nexport * as tags from \"./tags\";\nexport * from \"./schemas/metadata/IJsDocTagInfo\";\nexport * from \"./schemas/json/IJsonSchemaApplication\";\nexport * from \"./schemas/json/IJsonSchemaCollection\";\nexport * from \"./schemas/json/IJsonSchemaUnit\";\nexport * from \"./AssertionGuard\";\nexport * from \"./IRandomGenerator\";\nexport * from \"./IValidation\";\nexport * from \"./TypeGuardError\";\nexport * from \"./Primitive\";\nexport * from \"./Resolved\";\nexport * from \"./CamelCase\";\nexport * from \"./PascalCase\";\nexport * from \"./SnakeCase\";\nexport * from \"./IReadableURLSearchParams\";\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with a\n * detailed reason, if the parametric value is not following the type `T`.\n * Otherwise, if the value is following the type `T`, the input parameter will\n * be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link is} function\n * instead. Otherwise, if you want to know all the errors, {@link validate} is\n * the way to go. Also, if you want to automatically cast the parametric value\n * to the type `T` when there is no problem (perform the assertion guard of\n * type).\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link assertEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assert<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Asserts a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with a\n * detailed reason, if the parametric value is not following the type `T`.\n * Otherwise, if the value is following the type `T`, the input parameter will\n * be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link is} function\n * instead. Otherwise, if you want to know all the errors, {@link validate} is\n * the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link assertEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assert<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Assertion guard of a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with a\n * detailed reason, if the parametric value is not following the type `T`.\n * Otherwise, if the value is following the type `T`, nothing will be returned,\n * but the input value will be automatically casted to the type `T`. This is the\n * concept of \"Assertion Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link is} function\n * instead. Otherwise, if you want to know all the errors, {@link validate} is\n * the way to go. Also, if you want to return the parametric value when there is\n * no problem, you can use {@link assert} function instead.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link assertGuardEquals}\n * function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertGuard<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Assertion guard of a value type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with a\n * detailed reason, if the parametric value is not following the type `T`.\n * Otherwise, if the value is following the type `T`, nothing will be returned,\n * but the input value will be automatically casted to the type `T`. This is the\n * concept of \"Assertion Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link is} function\n * instead. Otherwise, if you want to know all the errors, {@link validate} is\n * the way to go. Also, if you want to return the parametric value when there is\n * no problem, you can use {@link assert} function instead.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link assertGuardEquals}\n * function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertGuard<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Tests a value type.\n *\n * Tests a parametric value type and returns whether it's following the type `T`\n * or not. If the parametric value is matched with the type `T`, `true` value\n * will be returned. Otherwise, if the parametric value is not following the\n * type `T`, `false` value will be returned.\n *\n * If what you want is not just knowing whether the parametric value is\n * following the type `T` or not, but throwing an exception with a detailed\n * reason, you can choose {@link assert} function instead. Also, if you want to\n * know all the errors with detailed reasons, {@link validate} function will be\n * useful.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link equals} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be tested\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Whether the parametric value is following the type `T` or not\n */\nexport declare function is<T>(input: T): input is T;\n/**\n * Tests a value type.\n *\n * Tests a parametric value type and returns whether it's following the type `T`\n * or not. If the parametric value is matched with the type `T`, `true` value\n * will be returned. Otherwise, if the parametric value is not following the\n * type `T`, `false` value will be returned.\n *\n * If what you want is not just knowing whether the parametric value is\n * following the type `T` or not, but throwing an exception with a detailed\n * reason, you can choose {@link assert} function instead. Also, if you want to\n * know all the errors with detailed reasons, {@link validate} function will be\n * useful.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link equals} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be tested\n * @returns Whether the parametric value is following the type `T` or not\n */\nexport declare function is<T>(input: unknown): input is T;\n/**\n * Validates a value type.\n *\n * Validates a parametric value type and archives all the type errors into an\n * {@link IValidation.errors} array, if the parametric value is not following the\n * type `T`. Of course, if the parametric value is following the type `T`, the\n * {@link IValidation.errors} array will be empty and {@link IValidation.success}\n * will have the `true` value.\n *\n * If what you want is not finding all the errors, but asserting the parametric\n * value type with exception throwing, you can choose {@link assert} function\n * instead. Otherwise, if you just want to know whether the parametric value is\n * matched with the type `T`, {@link is} function is the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link validateEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be validated\n * @returns Validation result\n */\nexport declare function validate<T>(input: T): IValidation<T>;\n/**\n * Validates a value type.\n *\n * Validates a parametric value type and archives all the type errors into an\n * {@link IValidation.errors} array, if the parametric value is not following the\n * type `T`. Of course, if the parametric value is following the type `T`, the\n * {@link IValidation.errors} array will be empty and {@link IValidation.success}\n * will have the `true` value.\n *\n * If what you want is not finding all the errors, but asserting the parametric\n * value type with exception throwing, you can choose {@link assert} function\n * instead. Otherwise, if you just want to know whether the parametric value is\n * matched with the type `T`, {@link is} function is the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link validateEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be validated\n * @returns Validation result\n */\nexport declare function validate<T>(input: unknown): IValidation<T>;\n/**\n * Asserts equality between a value and its type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with\n * detailed reason, if the parametric value is not following the type `T` or\n * some superfluous property that is not listed on the type `T` has been found.\n * Otherwise, the value is following the type `T` without any superfluous\n * property, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link equals}\n * function instead. Otherwise, if you want to know all the errors,\n * {@link validateEquals} is the way to go.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link assert} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertEquals<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Asserts equality between a value and its type.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with\n * detailed reason, if the parametric value is not following the type `T` or\n * some superfluous property that is not listed on the type `T` has been found.\n * Otherwise, the value is following the type `T` without any superfluous\n * property, just input parameter would be returned.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link equals}\n * function instead. Otherwise, if you want to know all the errors,\n * {@link validateEquals} is the way to go.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link assert} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertEquals<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): T;\n/**\n * Assertion guard of a type with equality.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with\n * detailed reason, if the parametric value is not following the type `T` or\n * some superfluous property that is not listed on the type `T` has been found.\n *\n * Otherwise, the value is following the type `T` without any superfluous\n * property, nothing will be returned, but the input value would be\n * automatically casted to the type `T`. This is the concept of \"Assertion\n * Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link equals}\n * function instead. Otherwise, if you want to know all the errors,\n * {@link validateEquals} is the way to go. Also, if you want to returns the\n * parametric value when no problem, you can use {@link assert} function\n * instead.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertEquals} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertGuardEquals<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Assertion guard of a type with equality.\n *\n * Asserts a parametric value type and throws a {@link TypeGuardError} with\n * detailed reason, if the parametric value is not following the type `T` or\n * some superfluous property that is not listed on the type `T` has been found.\n *\n * Otherwise, the value is following the type `T` without any superfluous\n * property, nothing will be returned, but the input value would be\n * automatically casted to the type `T`. This is the concept of \"Assertion\n * Guard\" of a value type.\n *\n * If what you want is not asserting but just knowing whether the parametric\n * value is following the type `T` or not, you can choose the {@link equals}\n * function instead. Otherwise, if you want to know all the errors,\n * {@link validateEquals} is the way to go. Also, if you want to returns the\n * parametric value when no problem, you can use {@link assertEquals} function\n * instead.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link assertGuard} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be asserted\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Parametric input value casted as `T`\n * @throws A {@link TypeGuardError} instance with a detailed reason\n */\nexport declare function assertGuardEquals<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): asserts input is T;\n/**\n * Tests equality between a value and its type.\n *\n * Tests a parametric value type and returns whether it's equivalent to the type\n * `T` or not. If the parametric value is matched with the type `T` and there's\n * not any superfluous property that is not listed on the type `T`, `true` value\n * will be returned. Otherwise, if the parametric value is not following the\n * type `T` or some superfluous property exists, `false` value will be\n * returned.\n *\n * If what you want is not just knowing whether the parametric value is\n * following the type `T` or not, but throwing an exception with a detailed\n * reason, you can choose {@link assertEquals} function instead. Also, if you\n * want to know all the errors with detailed reasons, {@link validateEquals}\n * function will be useful.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link is} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be tested\n * @returns Whether the parametric value is equivalent to the type `T` or not\n */\nexport declare function equals<T>(input: T): input is T;\n/**\n * Tests equality between a value and its type.\n *\n * Tests a parametric value type and returns whether it's equivalent to the type\n * `T` or not. If the parametric value is matched with the type `T` and there's\n * not any superfluous property that is not listed on the type `T`, `true` value\n * will be returned. Otherwise, if the parametric value is not following the\n * type `T` or some superfluous property exists, `false` value will be\n * returned.\n *\n * If what you want is not just knowing whether the parametric value is\n * following the type `T` or not, but throwing an exception with a detailed\n * reason, you can choose {@link assertEquals} function instead. Also, if you\n * want to know all the errors with detailed reasons, {@link validateEquals}\n * function will be useful.\n *\n * On the other hand, if you want to allow superfluous property that is not\n * enrolled to the type `T`, you can use {@link is} function instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input A value to be tested\n * @returns Whether the parametric value is equivalent to the type `T` or not\n */\nexport declare function equals<T>(input: unknown): input is T;\n/**\n * Validates equality between a value and its type.\n *\n * Validates a parametric value type and archives all the type errors into an\n * {@link IValidation.errors} array, if the parametric value is not following the\n * type `T` or some superfluous property that is not listed on the type `T` has\n * been found. Of course, if the parametric value is following the type `T` and\n * no superfluous property exists, the {@link IValidation.errors} array would be\n * empty and {@link IValidation.success} would have the `true` value.\n *\n * If what you want is not finding all the error, but asserting the parametric\n * value type with exception throwing, you can choose {@link assert} function\n * instead. Otherwise, you just want to know whether the parametric value is\n * matched with the type `T`, {@link is} function is the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link validateEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Type Of the input value\n * @param input A value to be validated\n * @returns Validation result\n */\nexport declare function validateEquals<T>(input: T): IValidation<T>;\n/**\n * Validates equality between a value and its type.\n *\n * Validates a parametric value type and archives all the type errors into an\n * {@link IValidation.errors} array, if the parametric value is not following the\n * type `T` or some superfluous property that is not listed on the type `T` has\n * been found. Of course, if the parametric value is following the type `T` and\n * no superfluous property exists, the {@link IValidation.errors} array would be\n * empty and {@link IValidation.success} would have the `true` value.\n *\n * If what you want is not finding all the error, but asserting the parametric\n * value type with exception throwing, you can choose {@link assert} function\n * instead. Otherwise, you just want to know whether the parametric value is\n * matched with the type `T`, {@link is} function is the way to go.\n *\n * On the other hand, if you don't want to allow any superfluous property that\n * is not enrolled to the type `T`, you can use {@link validateEquals} function\n * instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Type Of the input value\n * @param input A value to be validated\n * @returns Validation result\n */\nexport declare function validateEquals<T>(input: unknown): IValidation<T>;\n/**\n * > You must configure the generic argument `T`.\n *\n * Generate random data.\n *\n * Generates a random data following type the `T`.\n *\n * For reference, this `typia.random()` function generates only primitive type.\n * If there're some methods in the type `T` or its nested instances, those would\n * be ignored. Also, when the type `T` has a `toJSON()` method, its return type\n * will be generated instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of data to generate\n * @param generator Random data generator\n * @returns Randomly generated data\n */\nexport declare function random(generator?: Partial<IRandomGenerator>): never;\n/**\n * Generate random data.\n *\n * Generates a random data following type the `T`.\n *\n * For reference, this `typia.random()` function generates only primitive type.\n * If there're some methods in the type `T` or its nested instances, those would\n * be ignored. Also, when the type `T` has a `toJSON()` method, its return type\n * will be generated instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of data to generate\n * @param generator Random data generator\n * @returns Randomly generated data\n */\nexport declare function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;\n/**\n * Creates a reusable {@link assert} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssert(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assert} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assert` function\n */\nexport declare function createAssert<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => T;\n/**\n * Creates a reusable {@link assertGuard} function.\n *\n * Note that, you've to declare the variable type of the factory function caller\n * like below. If you don't declare the variable type, compilation error be\n * thrown. This is the special rule of the TypeScript compiler.\n *\n * ```typescript\n * // MUST DECLARE THE VARIABLE TYPE\n * const func: typia.AssertionGuard<number> = typia.createAssertGuard<number>();\n *\n * // IF NOT, COMPILATION ERROR BE OCCURRED\n * const func = typia.createAssertGuard<number>();\n * ```\n *\n * > _Assertions require every name in the call target to be declared with an_\n * > _explicit type annotation._\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertGuard(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertGuard} function.\n *\n * Note that, you've to declare the variable type of the factory function caller\n * like below. If you don't declare the variable type, compilation error be\n * thrown. This is the special rule of the TypeScript compiler.\n *\n * ```typescript\n * // MUST DECLARE THE VARIABLE TYPE\n * const func: typia.AssertionGuard<number> = typia.createAssertGuard<number>();\n *\n * // IF NOT, COMPILATION ERROR BE OCCURRED\n * const func = typia.createAssertGuard<number>();\n * ```\n *\n * > _Assertions require every name in the call target to be declared with an_\n * > _explicit type annotation._\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n */\nexport declare function createAssertGuard<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => AssertionGuard<T>;\n/**\n * Creates a reusable {@link is} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIs(): never;\n/**\n * Creates a reusable {@link is} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `is` function\n */\nexport declare function createIs<T>(): (input: unknown) => input is T;\n/**\n * Creates a reusable {@link validate} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidate(): never;\n/**\n * Creates a reusable {@link validate} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validate` function\n */\nexport declare function createValidate<T>(): ((input: unknown) => IValidation<T>) & StandardSchemaV1<unknown, T>;\n/**\n * Creates a reusable {@link assertEquals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertEquals(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertEquals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertEquals` function\n */\nexport declare function createAssertEquals<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => T;\n/**\n * Creates a reusable {@link assertGuardEquals} function.\n *\n * Note that, you've to declare the variable type of the factory function caller\n * like below. If you don't declare the variable type, compilation error be\n * thrown. This is the special rule of the TypeScript compiler.\n *\n * ```typescript\n * // MUST DECLARE THE VARIABLE TYPE\n * const func: typia.AssertionGuard<number> = typia.createAssertGuardEquals<number>();\n *\n * // IF NOT, COMPILATION ERROR BE OCCURRED\n * const func = typia.createAssertGuardEquals<number>();\n * ```\n *\n * > _Assertions require every name in the call target to be declared with an_\n * > _explicit type annotation._\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertGuardEquals(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertGuardEquals} function.\n *\n * Note that, you've to declare the variable type of the factory function caller\n * like below. If you don't declare the variable type, compilation error be\n * thrown. This is the special rule of the TypeScript compiler.\n *\n * ```typescript\n * // MUST DECLARE THE VARIABLE TYPE\n * const func: typia.AssertionGuard<number> = typia.createAssertGuardEquals<number>();\n *\n * // IF NOT, COMPILATION ERROR BE OCCURRED\n * const func = typia.createAssertGuardEquals<number>();\n * ```\n *\n * > _Assertions require every name in the call target to be declared with an_\n * > _explicit type annotation._\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n */\nexport declare function createAssertGuardEquals<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: unknown) => AssertionGuard<T>;\n/**\n * Creates a reusable {@link equals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createEquals(): never;\n/**\n * Creates a reusable {@link equals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `equals` function\n */\nexport declare function createEquals<T>(): (input: unknown) => input is T;\n/**\n * Creates a reusable {@link validateEquals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateEquals(): never;\n/**\n * Creates a reusable {@link validateEquals} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validateEquals` function\n */\nexport declare function createValidateEquals<T>(): ((input: unknown) => IValidation<T>) & StandardSchemaV1<unknown, T>;\n/**\n * Creates a reusable {@link random} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param generator Random data generator\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createRandom(generator?: Partial<IRandomGenerator>): never;\n/**\n * Creates a reusable {@link random} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param generator Random data generator\n * @returns A reusable `random` function\n */\nexport declare function createRandom<T>(generator?: Partial<IRandomGenerator>): () => Resolved<T>;\n",
   "node_modules/typia/lib/notations.d.ts": "import { CamelCase } from \"./CamelCase\";\nimport { IValidation } from \"./IValidation\";\nimport { PascalCase } from \"./PascalCase\";\nimport { SnakeCase } from \"./SnakeCase\";\nimport { TypeGuardError } from \"./TypeGuardError\";\n/**\n * Convert to camel case.\n *\n * Convert every property names of nested objects to follow the camel case\n * convention.\n *\n * For reference, this `typia.notations.camel()` function does not validate the\n * input value type. It just believes that the input value is following the type\n * `T`. Therefore, if you can't ensure the input value type, it would be better\n * to call one of them below:\n *\n * - {@link assertCamel}\n * - {@link isCamel}\n * - {@link validateCamel}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Camel case object\n */\nexport declare function camel<T>(input: T): CamelCase<T>;\n/**\n * Converts to camel case with type assertion.\n *\n * Convert every property names of nested objects to follow the camel case\n * convention. If the input value does not follow the type `T`, it throws\n * {@link TypeGuardError}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Camel case object\n */\nexport declare function assertCamel<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): CamelCase<T>;\n/**\n * Converts to camel case with type assertion.\n *\n * Convert every property names of nested objects to follow the camel case\n * convention. If the input value does not follow the type `T`, it throws\n * {@link TypeGuardError}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Camel case object\n */\nexport declare function assertCamel<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): CamelCase<T>;\n/**\n * Converts to camel case with type checking.\n *\n * Convert every property names of nested objects to follow the camel case\n * convention. If the input value does not follow the type `T`, it returns\n * `null` value instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Camel case object when exact type, otherwise null\n */\nexport declare function isCamel<T>(input: T): CamelCase<T> | null;\n/**\n * Converts to camel case with type checking.\n *\n * Convert every property names of nested objects to follow the camel case\n * convention. If the input value does not follow the type `T`, it returns\n * `null` value instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Camel case object when exact type, otherwise null\n */\nexport declare function isCamel<T>(input: unknown): CamelCase<T> | null;\n/**\n * Converts to camel case with type validation.\n *\n * Convert every property names of nested objects to follow the camel case\n * convention. If the input value does not follow the type `T`, it returns\n * {@link IValidation.Failure} object. Otherwise, there's no problem on the input\n * value, camel cased converted data would be stored in the `data` property of\n * the output {@link IValidation.Success} object.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Validation result with camel case object\n */\nexport declare function validateCamel<T>(input: T): IValidation<CamelCase<T>>;\n/**\n * Converts to camel case with type validation.\n *\n * Convert every property names of nested objects to follow the camel case\n * convention. If the input value does not follow the type `T`, it returns\n * {@link IValidation.Failure} object. Otherwise, there's no problem on the input\n * value, camel cased converted data would be stored in the `data` property of\n * the output {@link IValidation.Success} object.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Validation result with camel case object\n */\nexport declare function validateCamel<T>(input: unknown): IValidation<CamelCase<T>>;\n/**\n * Convert to pascal case.\n *\n * Convert every property names of nested objects to follow the pascal case\n * convention.\n *\n * For reference, this `typia.notations.pascal()` function does not validate the\n * input value type. It just believes that the input value is following the type\n * `T`. Therefore, if you can't ensure the input value type, it would be better\n * to call one of them below:\n *\n * - {@link assertPascal}\n * - {@link isPascal}\n * - {@link validatePascal}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Pascal case object\n */\nexport declare function pascal<T>(input: T): PascalCase<T>;\n/**\n * Converts to pascal case with type assertion.\n *\n * Convert every property names of nested objects to follow the pascal case\n * convention. If the input value does not follow the type `T`, it throws\n * {@link TypeGuardError}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Pascal case object\n */\nexport declare function assertPascal<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): PascalCase<T>;\n/**\n * Converts to pascal case with type assertion.\n *\n * Convert every property names of nested objects to follow the pascal case\n * convention. If the input value does not follow the type `T`, it throws\n * {@link TypeGuardError}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Pascal case object\n */\nexport declare function assertPascal<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): PascalCase<T>;\n/**\n * Converts to pascal case with type checking.\n *\n * Convert every property names of nested objects to follow the pascal case\n * convention. If the input value does not follow the type `T`, it returns\n * `null` value instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Pascal case object when exact type, otherwise null\n */\nexport declare function isPascal<T>(input: T): PascalCase<T> | null;\n/**\n * Converts to pascal case with type checking.\n *\n * Convert every property names of nested objects to follow the pascal case\n * convention. If the input value does not follow the type `T`, it returns\n * `null` value instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Pascal case object when exact type, otherwise null\n */\nexport declare function isPascal<T>(input: unknown): PascalCase<T> | null;\n/**\n * Converts to pascal case with type validation.\n *\n * Convert every property names of nested objects to follow the pascal case\n * convention. If the input value does not follow the type `T`, it returns\n * {@link IValidation.Failure} object. Otherwise, there's no problem on the input\n * value, pascal cased converted data would be stored in the `data` property of\n * the output {@link IValidation.Success} object.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Validation result with pascal case object\n */\nexport declare function validatePascal<T>(input: T): IValidation<PascalCase<T>>;\n/**\n * Converts to pascal case with type validation.\n *\n * Convert every property names of nested objects to follow the pascal case\n * convention. If the input value does not follow the type `T`, it returns\n * {@link IValidation.Failure} object. Otherwise, there's no problem on the input\n * value, pascal cased converted data would be stored in the `data` property of\n * the output {@link IValidation.Success} object.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Validation result with pascal case object\n */\nexport declare function validatePascal<T>(input: unknown): IValidation<PascalCase<T>>;\n/**\n * Convert to snake case.\n *\n * Convert every property names of nested objects to follow the snake case\n * convention.\n *\n * For reference, this `typia.notations.snake()` function does not validate the\n * input value type. It just believes that the input value is following the type\n * `T`. Therefore, if you can't ensure the input value type, it would be better\n * to call one of them below:\n *\n * - {@link assertSnake}\n * - {@link isSnake}\n * - {@link validateSnake}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Snake case object\n */\nexport declare function snake<T>(input: T): SnakeCase<T>;\n/**\n * Converts to snake case with type assertion.\n *\n * Convert every property names of nested objects to follow the snake case\n * convention. If the input value does not follow the type `T`, it throws\n * {@link TypeGuardError}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Snake case object\n */\nexport declare function assertSnake<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): SnakeCase<T>;\n/**\n * Converts to snake case with type assertion.\n *\n * Convert every property names of nested objects to follow the snake case\n * convention. If the input value does not follow the type `T`, it throws\n * {@link TypeGuardError}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Snake case object\n */\nexport declare function assertSnake<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): SnakeCase<T>;\n/**\n * Converts to snake case with type checking.\n *\n * Convert every property names of nested objects to follow the snake case\n * convention. If the input value does not follow the type `T`, it returns\n * `null` value instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Snake case object when exact type, otherwise null\n */\nexport declare function isSnake<T>(input: T): SnakeCase<T> | null;\n/**\n * Converts to snake case with type checking.\n *\n * Convert every property names of nested objects to follow the snake case\n * convention. If the input value does not follow the type `T`, it returns\n * `null` value instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Snake case object when exact type, otherwise null\n */\nexport declare function isSnake<T>(input: unknown): SnakeCase<T> | null;\n/**\n * Converts to snake case with type validation.\n *\n * Convert every property names of nested objects to follow the snake case\n * convention. If the input value does not follow the type `T`, it returns\n * {@link IValidation.Failure} object. Otherwise, there's no problem on the input\n * value, snake cased converted data would be stored in the `data` property of\n * the output {@link IValidation.Success} object.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Validation result with snake case object\n */\nexport declare function validateSnake<T>(input: T): IValidation<SnakeCase<T>>;\n/**\n * Converts to snake case with type validation.\n *\n * Convert every property names of nested objects to follow the snake case\n * convention. If the input value does not follow the type `T`, it returns\n * {@link IValidation.Failure} object. Otherwise, there's no problem on the input\n * value, snake cased converted data would be stored in the `data` property of\n * the output {@link IValidation.Success} object.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param input Target object\n * @returns Validation result with snake case object\n */\nexport declare function validateSnake<T>(input: unknown): IValidation<SnakeCase<T>>;\n/**\n * Creates a reusable {@link camel} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createCamel(): never;\n/**\n * Creates a reusable {@link camel} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `camel` function\n */\nexport declare function createCamel<T>(): (input: T) => CamelCase<T>;\n/**\n * Creates a reusable {@link assertCamel} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertCamel(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertCamel} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertCamel` function\n */\nexport declare function createAssertCamel<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: T) => CamelCase<T>;\n/**\n * Creates a reusable {@link isCamel} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsCamel(): never;\n/**\n * Creates a reusable {@link isCamel} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `isCamel` function\n */\nexport declare function createIsCamel<T>(): (input: T) => CamelCase<T> | null;\n/**\n * Creates a reusable {@link validateCamel} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateCamel(): never;\n/**\n * Creates a reusable {@link validateCamel} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validateCamel` function\n */\nexport declare function createValidateCamel<T>(): (input: T) => IValidation<CamelCase<T>>;\n/**\n * Creates a reusable {@link pascal} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createPascal(): never;\n/**\n * Creates a reusable {@link pascal} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `pascal` function\n */\nexport declare function createPascal<T>(): (input: T) => PascalCase<T>;\n/**\n * Creates a reusable {@link assertPascal} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertPascal(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertPascal} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertPascal` function\n */\nexport declare function createAssertPascal<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: T) => PascalCase<T>;\n/**\n * Creates a reusable {@link isPascal} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsPascal(): never;\n/**\n * Creates a reusable {@link isPascal} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `isPascal` function\n */\nexport declare function createIsPascal<T>(): (input: T) => PascalCase<T> | null;\n/**\n * Creates a reusable {@link validatePascal} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidatePascal(): never;\n/**\n * Creates a reusable {@link validatePascal} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validatePascal` function\n */\nexport declare function createValidatePascal<T>(): (input: T) => IValidation<PascalCase<T>>;\n/**\n * Creates a reusable {@link snake} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createSnake(): never;\n/**\n * Creates a reusable {@link snake} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `snake` function\n */\nexport declare function createSnake<T>(): (input: T) => SnakeCase<T>;\n/**\n * Creates a reusable {@link assertSnake} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertSnake(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertSnake} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertSnake` function\n */\nexport declare function createAssertSnake<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: T) => SnakeCase<T>;\n/**\n * Creates a reusable {@link isSnake} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsSnake(): never;\n/**\n * Creates a reusable {@link isSnake} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `isSnake` function\n */\nexport declare function createIsSnake<T>(): (input: T) => SnakeCase<T> | null;\n/**\n * Creates a reusable {@link validateSnake} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until be configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateSnake(): never;\n/**\n * Creates a reusable {@link validateSnake} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the input value\n * @returns A reusable `validateSnake` function\n */\nexport declare function createValidateSnake<T>(): (input: T) => IValidation<SnakeCase<T>>;\n",
   "node_modules/typia/lib/programmers/AssertProgrammer.d.ts": "import ts from \"typescript\";\nimport { IProgrammerProps } from \"../transformers/IProgrammerProps\";\nimport { ITypiaContext } from \"../transformers/ITypiaContext\";\nimport { FeatureProgrammer } from \"./FeatureProgrammer\";\nimport { FunctionProgrammer } from \"./helpers/FunctionProgrammer\";\nexport declare namespace AssertProgrammer {\n    interface IConfig {\n        equals: boolean;\n        guard: boolean;\n    }\n    interface IProps extends IProgrammerProps {\n        config: IConfig;\n    }\n    const decompose: (props: {\n        config: IConfig;\n        context: ITypiaContext;\n        functor: FunctionProgrammer;\n        type: ts.Type;\n        name: string | undefined;\n        init?: ts.Expression | undefined;\n    }) => FeatureProgrammer.IDecomposed;\n    const write: (props: IProps) => ts.CallExpression;\n    namespace Guardian {\n        const identifier: () => ts.Identifier;\n        const parameter: (props: {\n            context: ITypiaContext;\n            init: ts.Expression | undefined;\n        }) => ts.ParameterDeclaration;\n        const type: (context: ITypiaContext) => ts.FunctionTypeNode;\n    }\n}\n",
   "node_modules/typia/lib/programmers/CheckerProgrammer.d.ts": "import ts from \"typescript\";\nimport { MetadataCollection } from \"../factories/MetadataCollection\";\nimport { Metadata } from \"../schemas/metadata/Metadata\";\nimport { MetadataObjectType } from \"../schemas/metadata/MetadataObjectType\";\nimport { ITypiaContext } from \"../transformers/ITypiaContext\";\nimport { FeatureProgrammer } from \"./FeatureProgrammer\";\nimport { FunctionProgrammer } from \"./helpers/FunctionProgrammer\";\nimport { ICheckEntry } from \"./helpers/ICheckEntry\";\nimport { IExpressionEntry } from \"./helpers/IExpressionEntry\";\nexport declare namespace CheckerProgrammer {\n    interface IConfig {\n        prefix: string;\n        path: boolean;\n        trace: boolean;\n        equals: boolean;\n        numeric: boolean;\n        addition?: () => ts.Statement[];\n        decoder?: (props: {\n            metadata: Metadata;\n            input: ts.Expression;\n            explore: IExplore;\n        }) => ts.Expression;\n        combiner: IConfig.Combiner;\n        atomist: (props: {\n            entry: ICheckEntry;\n            input: ts.Expression;\n            explore: IExplore;\n        }) => ts.Expression;\n        joiner: IConfig.IJoiner;\n        success: ts.Expression;\n    }\n    namespace IConfig {\n        interface Combiner {\n            (props: {\n                explore: IExplore;\n                logic: \"and\" | \"or\";\n                input: ts.Expression;\n                binaries: IBinary[];\n                expected: string;\n            }): ts.Expression;\n        }\n        interface IJoiner {\n            object(props: {\n                input: ts.Expression;\n                entries: IExpressionEntry<ts.Expression>[];\n            }): ts.Expression;\n            array(props: {\n                input: ts.Expression;\n                arrow: ts.ArrowFunction;\n            }): ts.Expression;\n            tuple?: undefined | ((exprs: ts.Expression[]) => ts.Expression);\n            failure(props: {\n                input: ts.Expression;\n                expected: string;\n                explore?: undefined | FeatureProgrammer.IExplore;\n            }): ts.Expression;\n            is?(expression: ts.Expression): ts.Expression;\n            required?(exp: ts.Expression): ts.Expression;\n            full?: undefined | ((props: {\n                condition: ts.Expression;\n                input: ts.Expression;\n                expected: string;\n                explore: IExplore;\n            }) => ts.Expression);\n        }\n    }\n    type IExplore = FeatureProgrammer.IExplore;\n    interface IBinary {\n        expression: ts.Expression;\n        combined: boolean;\n    }\n    const compose: (props: {\n        context: ITypiaContext;\n        config: IConfig;\n        functor: FunctionProgrammer;\n        type: ts.Type;\n        name: string | undefined;\n    }) => FeatureProgrammer.IComposed;\n    const write: (props: {\n        context: ITypiaContext;\n        config: IConfig;\n        functor: FunctionProgrammer;\n        type: ts.Type;\n        name?: string;\n    }) => ts.ArrowFunction;\n    const write_object_functions: (props: {\n        context: ITypiaContext;\n        config: IConfig;\n        functor: FunctionProgrammer;\n        collection: MetadataCollection;\n    }) => ts.VariableStatement[];\n    const write_union_functions: (props: {\n        context: ITypiaContext;\n        config: IConfig;\n        functor: FunctionProgrammer;\n        collection: MetadataCollection;\n    }) => ts.VariableStatement[];\n    const write_array_functions: (props: {\n        context: ITypiaContext;\n        config: IConfig;\n        functor: FunctionProgrammer;\n        collection: MetadataCollection;\n    }) => ts.VariableStatement[];\n    const write_tuple_functions: (props: {\n        context: ITypiaContext;\n        config: IConfig;\n        functor: FunctionProgrammer;\n        collection: MetadataCollection;\n    }) => ts.VariableStatement[];\n    const decode: (props: {\n        context: ITypiaContext;\n        config: IConfig;\n        functor: FunctionProgrammer;\n        input: ts.Expression;\n        metadata: Metadata;\n        explore: IExplore;\n    }) => ts.Expression;\n    const decode_object: (props: {\n        config: IConfig;\n        functor: FunctionProgrammer;\n        object: MetadataObjectType;\n        input: ts.Expression;\n        explore: IExplore;\n    }) => ts.CallExpression;\n}\n",
@@ -958,7 +958,7 @@
   "node_modules/typia/lib/programmers/internal/stringify_regular_properties.d.ts": "export {};\n",
   "node_modules/typia/lib/programmers/internal/template_to_pattern.d.ts": "export {};\n",
   "node_modules/typia/lib/programmers/internal/wrap_metadata_rest_tuple.d.ts": "export {};\n",
-  "node_modules/typia/lib/programmers/json/JsonApplicationProgrammer.d.ts": "import { MetadataFactory } from \"../../factories/MetadataFactory\";\nimport { __IJsonApplication } from \"../../schemas/json/__IJsonApplication\";\nimport { IJsDocTagInfo } from \"../../schemas/metadata/IJsDocTagInfo\";\nimport { Metadata } from \"../../schemas/metadata/Metadata\";\nimport { MetadataProperty } from \"../../schemas/metadata/MetadataProperty\";\nexport declare namespace JsonApplicationProgrammer {\n    const validate: (metadata: Metadata, explore: MetadataFactory.IExplore) => string[];\n    const write: <Version extends \"3.0\" | \"3.1\">(props: {\n        version: Version;\n        metadata: Metadata;\n        filter?: (prop: MetadataProperty) => boolean;\n    }) => __IJsonApplication<Version>;\n    const writeDescription: <Kind extends \"summary\" | \"title\">(props: {\n        description: string | null;\n        jsDocTags: IJsDocTagInfo[];\n        kind: Kind;\n    }) => Kind extends \"summary\" ? {\n        summary?: string;\n        description?: string;\n    } : {\n        title?: string;\n        description?: string;\n    };\n}\n",
+  "node_modules/typia/lib/programmers/json/JsonApplicationProgrammer.d.ts": "import { MetadataFactory } from \"../../factories/MetadataFactory\";\nimport { IJsonSchemaApplication } from \"../../schemas/json/IJsonSchemaApplication\";\nimport { IJsDocTagInfo } from \"../../schemas/metadata/IJsDocTagInfo\";\nimport { Metadata } from \"../../schemas/metadata/Metadata\";\nimport { MetadataProperty } from \"../../schemas/metadata/MetadataProperty\";\nexport declare namespace JsonApplicationProgrammer {\n    const validate: (metadata: Metadata, explore: MetadataFactory.IExplore) => string[];\n    const write: <Version extends \"3.0\" | \"3.1\">(props: {\n        version: Version;\n        metadata: Metadata;\n        filter?: (prop: MetadataProperty) => boolean;\n    }) => IJsonSchemaApplication<Version>;\n    const writeDescription: <Kind extends \"summary\" | \"title\">(props: {\n        description: string | null;\n        jsDocTags: IJsDocTagInfo[];\n        kind: Kind;\n    }) => Kind extends \"summary\" ? {\n        summary?: string;\n        description?: string;\n    } : {\n        title?: string;\n        description?: string;\n    };\n}\n",
   "node_modules/typia/lib/programmers/json/JsonAssertParseProgrammer.d.ts": "import ts from \"typescript\";\nimport { IProgrammerProps } from \"../../transformers/IProgrammerProps\";\nimport { ITypiaContext } from \"../../transformers/ITypiaContext\";\nimport { FeatureProgrammer } from \"../FeatureProgrammer\";\nimport { FunctionProgrammer } from \"../helpers/FunctionProgrammer\";\nexport declare namespace JsonAssertParseProgrammer {\n    const decompose: (props: {\n        context: ITypiaContext;\n        functor: FunctionProgrammer;\n        type: ts.Type;\n        name: string | undefined;\n        init: ts.Expression | undefined;\n    }) => FeatureProgrammer.IDecomposed;\n    const write: (props: IProgrammerProps) => ts.CallExpression;\n}\n",
   "node_modules/typia/lib/programmers/json/JsonAssertStringifyProgrammer.d.ts": "import ts from \"typescript\";\nimport { IProgrammerProps } from \"../../transformers/IProgrammerProps\";\nimport { ITypiaContext } from \"../../transformers/ITypiaContext\";\nimport { FeatureProgrammer } from \"../FeatureProgrammer\";\nimport { FunctionProgrammer } from \"../helpers/FunctionProgrammer\";\nexport declare namespace JsonAssertStringifyProgrammer {\n    const decompose: (props: {\n        context: ITypiaContext;\n        functor: FunctionProgrammer;\n        type: ts.Type;\n        name: string | undefined;\n        init: ts.Expression | undefined;\n    }) => FeatureProgrammer.IDecomposed;\n    const write: (props: IProgrammerProps) => ts.CallExpression;\n}\n",
   "node_modules/typia/lib/programmers/json/JsonIsParseProgrammer.d.ts": "import ts from \"typescript\";\nimport { IProgrammerProps } from \"../../transformers/IProgrammerProps\";\nimport { ITypiaContext } from \"../../transformers/ITypiaContext\";\nimport { FeatureProgrammer } from \"../FeatureProgrammer\";\nimport { FunctionProgrammer } from \"../helpers/FunctionProgrammer\";\nexport declare namespace JsonIsParseProgrammer {\n    const decompose: (props: {\n        context: ITypiaContext;\n        functor: FunctionProgrammer;\n        type: ts.Type;\n        name: string | undefined;\n    }) => FeatureProgrammer.IDecomposed;\n    const write: (props: IProgrammerProps) => ts.CallExpression;\n}\n",
@@ -996,10 +996,9 @@
   "node_modules/typia/lib/programmers/protobuf/ProtobufValidateEncodeProgrammer.d.ts": "import ts from \"typescript\";\nimport { IProgrammerProps } from \"../../transformers/IProgrammerProps\";\nimport { ITypiaContext } from \"../../transformers/ITypiaContext\";\nimport { FeatureProgrammer } from \"../FeatureProgrammer\";\nimport { FunctionProgrammer } from \"../helpers/FunctionProgrammer\";\nexport declare namespace ProtobufValidateEncodeProgrammer {\n    const decompose: (props: {\n        context: ITypiaContext;\n        modulo: ts.LeftHandSideExpression;\n        functor: FunctionProgrammer;\n        type: ts.Type;\n        name: string | undefined;\n    }) => FeatureProgrammer.IDecomposed;\n    const write: (props: IProgrammerProps) => ts.CallExpression;\n}\n",
   "node_modules/typia/lib/protobuf.d.ts": "import { IValidation } from \"./IValidation\";\nimport { Resolved } from \"./Resolved\";\nimport { TypeGuardError } from \"./TypeGuardError\";\n/**\n * > You must configure the generic argument `T`.\n *\n * Protocol Buffer Message Schema.\n *\n * Creates a Protocol Buffer Message Schema from a TypeScript type. The message\n * schema would be returned as a string value, and it can be used to share with\n * other developers/languages/frameworks.\n *\n * For reference, Protocol Buffer has lots of restrictions, so that expression\n * power of Protocol Buffer is not enough strong to fully meet the TypeScript\n * type specs. In such reason, if you put a TypeScript type that is not\n * compatible with Protocol Buffer, this function would throw compilation\n * errors.\n *\n * - [Restrictions of Protocol\n *   Buffer](https://typia.io/docs/protobuf/message/#restrictions)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @returns Protocol Buffer Message Schema.\n */\nexport declare function message(): never;\n/**\n * Protocol Buffer Message Schema.\n *\n * Creates a Protocol Buffer Message Schema from a TypeScript type. The message\n * schema would be returned as a string value, and it can be used to share with\n * other developers/languages/frameworks.\n *\n * For reference, Protocol Buffer has lots of restrictions, so that expression\n * power of Protocol Buffer is not enough strong to fully meet the TypeScript\n * type specs. In such reason, if you put a TypeScript type that is not\n * compatible with Protocol Buffer, this function would throw compilation\n * errors.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @returns Protocol Buffer Message Schema.\n */\nexport declare function message<T>(): string;\n/**\n * > You must configure the generic argument `T`.\n *\n * Protocol Buffer Decoder.\n *\n * `typia.protobuf.decode()` is a function decoding a binary data of Protocol\n * Buffer format to a TypeScript instance.\n *\n * For reference, as Protocol Buffer handles binary data directly, there's no\n * way when `input` binary data was not encoded from the `T` typed value. In\n * that case, unexpected behavior or internal error would be occurred.\n * Therefore, I recommend you to encode binary data of Protocol Buffer from type\n * safe encode functions like below. Use {@link encode} function only when you\n * can ensure it.\n *\n * - {@link assertEncode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * Also, `typia` is providing type safe decoders like {@link assertDecode}, but\n * it is just for additional type validation like `number & Minimum<7>` or\n * `string & Format<\"uuid\">` cases, that are represented by [custom\n * tags](https://typia.io/docs/validators/tags). Thus, I repeat that, you've to\n * ensure the type safety when using decoder functions.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of decoded value\n * @param input Protobuf Buffer binary data\n * @returns Decoded value\n */\nexport declare function decode(input: Uint8Array): never;\n/**\n * Protocol Buffer Decoder.\n *\n * `typia.protobuf.decode()` is a function decoding a binary data of Protocol\n * Buffer format to a TypeScript instance.\n *\n * For reference, as Protocol Buffer handles binary data directly, there's no\n * way when `input` binary data was not encoded from the `T` typed value. In\n * that case, unexpected behavior or internal error would be occurred.\n * Therefore, I recommend you to encode binary data of Protocol Buffer from type\n * safe encode functions like below. Use {@link encode} function only when you\n * can ensure it.\n *\n * - {@link assertEncode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * Also, `typia` is providing type safe decoders like {@link assertDecode}, but\n * it is just for additional type validation like `number & Minimum<7>` or\n * `string & Format<\"uuid\">` cases, that are represented by [custom\n * tags](https://typia.io/docs/validators/tags). Thus, I repeat that, you've to\n * ensure the type safety when using decoder functions.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of decoded value\n * @param input Protobuf Buffer binary data\n * @returns Decoded value\n */\nexport declare function decode<T>(input: Uint8Array): Resolved<T>;\n/**\n * > You must configure the generic argument `T`.\n *\n * Protocol Buffer Decoder wity type assertion, but not safe.\n *\n * `typia.protobuf.assertDecode()` is a combination function of {@link decode}\n * and {@link assert} function. Therefore, it decodes a binary data of Protocol\n * Buffer to a TypeScript instance, and performs type assertion process. If\n * decoded value is following the type `T`, it returns the decoded value.\n * Otherwise, it throws {@link TypeGuardError} instead.\n *\n * However, note that, this validation is not always safe. It just performs\n * additional type assertion like `number & Minimum<7>` or `string &\n * Format<\"uuid\">` cases, that are represented by [custom\n * tags](https://typia.io/docs/validators/tags). Therefore, when using\n * `typia.protobuf.assertDecode<T>()` function, you have to ensure the type\n * safety by yourself.\n *\n * In such type safety reason, I recommend you to use type safe encode\n * functions.\n *\n * - {@link assertEncode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of decoded value\n * @param input Protobuf Buffer binary data\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Decoded value\n */\nexport declare function assertDecode(input: Uint8Array, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Protocol Buffer Decoder wity type assertion, but not safe.\n *\n * `typia.protobuf.assertDecode()` is a combination function of {@link decode}\n * and {@link assert} function. Therefore, it decodes a binary data of Protocol\n * Buffer to a TypeScript instance, and performs type assertion process. If\n * decoded value is following the type `T`, it returns the decoded value.\n * Otherwise, it throws {@link TypeGuardError} instead.\n *\n * However, note that, this validation is not always safe. It just performs\n * additional type assertion like `number & Minimum<7>` or `string &\n * Format<\"uuid\">` cases, that are represented by [custom\n * tags](https://typia.io/docs/validators/tags). Therefore, when using\n * `typia.protobuf.assertDecode<T>()` function, you have to ensure the type\n * safety by yourself.\n *\n * In such type safety reason, I recommend you to use type safe encode\n * functions.\n *\n * - {@link assertEncode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of decoded value\n * @param input Protobuf Buffer binary data\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Decoded value\n */\nexport declare function assertDecode<T>(input: Uint8Array, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): Resolved<T>;\n/**\n * > You must configure the generic argument `T`.\n *\n * Protocol Buffer Decoder wity type checking, but not safe.\n *\n * `typia.protobuf.isDecode()` is a combination function of {@link decode} and\n * {@link is} function. Therefore, it decodes a binary data of Protocol Buffer to\n * a TypeScript instance, and performs type checking process. If decoded value\n * is following the type `T`, it returns the decoded value. Otherwise, it\n * returns `null` value instead.\n *\n * However, note that, this validation is not always safe. It just performs\n * additional type checking like `number & Minimum<7>` or `string &\n * Format<\"uuid\">` cases, that are represented by [custom\n * tags](https://typia.io/docs/validators/tags). Therefore, when using\n * `typia.protobuf.isDecode<T>()` function, you have to ensure the type safety\n * by yourself.\n *\n * In such type safety reason, I recommend you to use type safe encode\n * functions.\n *\n * - {@link assertEncode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of decoded value\n * @param input Protobuf Buffer binary data\n * @returns Decoded value\n */\nexport declare function isDecode(input: Uint8Array): never;\n/**\n * Protocol Buffer Decoder wity type checking, but not safe.\n *\n * `typia.protobuf.isDecode()` is a combination function of {@link decode} and\n * {@link is} function. Therefore, it decodes a binary data of Protocol Buffer to\n * a TypeScript instance, and performs type checking process. If decoded value\n * is following the type `T`, it returns the decoded value. Otherwise, it\n * returns `null` value instead.\n *\n * However, note that, this validation is not always safe. It just performs\n * additional type checking like `number & Minimum<7>` or `string &\n * Format<\"uuid\">` cases, that are represented by [custom\n * tags](https://typia.io/docs/validators/tags). Therefore, when using\n * `typia.protobuf.isDecode<T>()` function, you have to ensure the type safety\n * by yourself.\n *\n * In such type safety reason, I recommend you to use type safe encode\n * functions.\n *\n * - {@link assertEncode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of decoded value\n * @param input Protobuf Buffer binary data\n * @returns Decoded value\n */\nexport declare function isDecode<T>(input: Uint8Array): Resolved<T> | null;\n/**\n * > You must configure the generic argument `T`.\n *\n * Protocol Buffer Decoder wity type validation, but not safe.\n *\n * `typia.protobuf.validateDecode()` is a combination function of {@link decode}\n * and {@link validate} function. Therefore, it decodes a binary data of Protocol\n * Buffer to a TypeScript instance, and performs type validation process. If\n * decoded value is following the type `T`, it returns the decoded value with\n * {@link IValidation.ISuccess} typed instance. Otherwise, it returns\n * {@link IValidation.IFailure} value instead with detailed error reasons.\n *\n * However, note that, this validation is not always safe. It just performs\n * additional type validation like `number & Minimum<7>` or `string &\n * Format<\"uuid\">` cases, that are represented by [custom\n * tags](https://typia.io/docs/validators/tags). Therefore, when using\n * `typia.protobuf.validateDecode<T>()` function, you have to ensure the type\n * safety by yourself.\n *\n * In such type safety reason, I recommend you to use type safe encode\n * functions.\n *\n * - {@link assertEncode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of decoded value\n * @param input Protobuf Buffer binary data\n * @returns Decoded value\n */\nexport declare function validateDecode(input: Uint8Array): never;\n/**\n * Protocol Buffer Decoder wity type validation, but not safe.\n *\n * `typia.protobuf.validateDecode()` is a combination function of {@link decode}\n * and {@link validate} function. Therefore, it decodes a binary data of Protocol\n * Buffer to a TypeScript instance, and performs type validation process. If\n * decoded value is following the type `T`, it returns the decoded value with\n * {@link IValidation.ISuccess} typed instance. Otherwise, it returns\n * {@link IValidation.IFailure} value instead with detailed error reasons.\n *\n * However, note that, this validation is not always safe. It just performs\n * additional type validation like `number & Minimum<7>` or `string &\n * Format<\"uuid\">` cases, that are represented by [custom\n * tags](https://typia.io/docs/validators/tags). Therefore, when using\n * `typia.protobuf.validateDecode<T>()` function, you have to ensure the type\n * safety by yourself.\n *\n * In such type safety reason, I recommend you to use type safe encode\n * functions.\n *\n * - {@link assertEncode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Expected type of decoded value\n * @param input Protobuf Buffer binary data\n * @returns Decoded value\n */\nexport declare function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;\n/**\n * Protocol Buffer Encoder.\n *\n * Converts an input value to a binary data of Protocol Buffer format.\n *\n * For reference, this `typia.protobuf.encode()` does not validate the `input`\n * value. It just believes that the `input` value is valid and converts it to a\n * binary data directly. Therefore, if you can't ensure the `input` value type,\n * it would better to call one of below functions instead.\n *\n * - {@link assertEncode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * By the way, you know what? Expression power of Protocol Buffer is not enough\n * strong to fully meet the TypeScript type specs. In such reason, if you put a\n * TypeScript type that is not compatible with Protocol Buffer, this function\n * would throw compilation errors.\n *\n * - [Restrictions of Protocol\n *   Buffer](https://typia.io/docs/protobuf/message/#restrictions)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the value input\n * @param input A value to encode\n * @returns Encoded binary data\n */\nexport declare function encode<T>(input: T): Uint8Array;\n/**\n * Protocol Buffer Encoder with type assertion.\n *\n * `typia.protobuf.assertEncode()` is a combination function of {@link assert}\n * and {@link encode}.\n *\n * Therefore, it converts an `input` value to a binary data of Protocol Buffer,\n * with type assertion. If `input` value is not valid, it throws\n * {@link TypeGuardError}. Otherwise, there's no problem on the `input` value,\n * Protocol Buffer binary data would be returned.\n *\n * If you can trust `input` value, or want to perform other type of validation,\n * use below functions instead.\n *\n * - {@link encode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * By the way, you know what? Expression power of Protocol Buffer is not enough\n * strong to fully meet the TypeScript type specs. In such reason, if you put a\n * TypeScript type that is not compatible with Protocol Buffer, this function\n * would throw compilation errors.\n *\n * - [Restrictions of Protocol\n *   Buffer](https://typia.io/docs/protobuf/message/#restrictions)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the value input\n * @param input A value to encode\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Encoded binary data\n */\nexport declare function assertEncode<T>(input: T, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): Uint8Array;\n/**\n * Protocol Buffer Encoder with type assertion.\n *\n * `typia.protobuf.assertEncode()` is a combination function of {@link assert}\n * and {@link encode}.\n *\n * Therefore, it converts an `input` value to a binary data of Protocol Buffer,\n * with type assertion. If `input` value is not valid, it throws\n * {@link TypeGuardError}. Otherwise, there's no problem on the `input` value,\n * Protocol Buffer binary data would be returned.\n *\n * If you can trust `input` value, or want to perform other type of validation,\n * use below functions instead.\n *\n * - {@link encode}\n * - {@link isEncode}\n * - {@link validateEncode}\n *\n * By the way, you know what? Expression power of Protocol Buffer is not enough\n * strong to fully meet the TypeScript type specs. In such reason, if you put a\n * TypeScript type that is not compatible with Protocol Buffer, this function\n * would throw compilation errors.\n *\n * - [Restrictions of Protocol\n *   Buffer](https://typia.io/docs/protobuf/message/#restrictions)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the value input\n * @param input A value to encode\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Encoded binary data\n */\nexport declare function assertEncode<T>(input: unknown, errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): Uint8Array;\n/**\n * Protocol Buffer Encoder with type checking.\n *\n * `typia.protobuf.isEncode()` is a combination function of {@link is} and\n * {@link encode}.\n *\n * Therefore, it converts an `input` value to a binary data of Protocol Buffer,\n * with type checking. If `input` value is not valid, it returns `null` value.\n * Otherwise, there's no problem on the `input` value, Protocol Buffer binary\n * data would be returned.\n *\n * If you can trust `input` value, or want to perform other type of validation,\n * use below functions instead.\n *\n * - {@link encode}\n * - {@link assertEncode}\n * - {@link validateEncode}\n *\n * By the way, you know what? Expression power of Protocol Buffer is not enough\n * strong to fully meet the TypeScript type specs. In such reason, if you put a\n * TypeScript type that is not compatible with Protocol Buffer, this function\n * would throw compilation errors.\n *\n * - [Restrictions of Protocol\n *   Buffer](https://typia.io/docs/protobuf/message/#restrictions)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the value input\n * @param input A value to encode\n * @returns Encoded binary data\n */\nexport declare function isEncode<T>(input: T): Uint8Array | null;\n/**\n * Protocol Buffer Encoder with type checking.\n *\n * `typia.protobuf.isEncode()` is a combination function of {@link is} and\n * {@link encode}.\n *\n * Therefore, it converts an `input` value to a binary data of Protocol Buffer,\n * with type checking. If `input` value is not valid, it returns `null` value.\n * Otherwise, there's no problem on the `input` value, Protocol Buffer binary\n * data would be returned.\n *\n * If you can trust `input` value, or want to perform other type of validation,\n * use below functions instead.\n *\n * - {@link encode}\n * - {@link assertEncode}\n * - {@link validateEncode}\n *\n * By the way, you know what? Expression power of Protocol Buffer is not enough\n * strong to fully meet the TypeScript type specs. In such reason, if you put a\n * TypeScript type that is not compatible with Protocol Buffer, this function\n * would throw compilation errors.\n *\n * - [Restrictions of Protocol\n *   Buffer](https://typia.io/docs/protobuf/message/#restrictions)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the value input\n * @param input A value to encode\n * @returns Encoded binary data\n */\nexport declare function isEncode<T>(input: unknown): Uint8Array | null;\n/**\n * Protocol Buffer Encoder with type validation.\n *\n * `typia.protobuf.validateEncode()` is a combination function of\n * {@link validation} and {@link encode}.\n *\n * Therefore, it converts an `input` value to a binary data of Protocol Buffer,\n * with type validation. If `input` value is not valid, it returns\n * {@link IValidation.IFailure} value with detailed error reasons. Otherwise,\n * there's no problem on the `input` value, Protocol Buffer binary data would be\n * stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * If you can trust `input` value, or want to perform other type of validation,\n * use below functions instead.\n *\n * - {@link encode}\n * - {@link assertEncode}\n * - {@link isEncode}\n *\n * By the way, you know what? Expression power of Protocol Buffer is not enough\n * strong to fully meet the TypeScript type specs. In such reason, if you put a\n * TypeScript type that is not compatible with Protocol Buffer, this function\n * would throw compilation errors.\n *\n * - [Restrictions of Protocol\n *   Buffer](https://typia.io/docs/protobuf/message/#restrictions)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the value input\n * @param input A value to encode\n * @returns Encoded binary data\n */\nexport declare function validateEncode<T>(input: T): IValidation<Uint8Array>;\n/**\n * Protocol Buffer Encoder with type validation.\n *\n * `typia.protobuf.validateEncode()` is a combination function of\n * {@link validation} and {@link encode}.\n *\n * Therefore, it converts an `input` value to a binary data of Protocol Buffer,\n * with type validation. If `input` value is not valid, it returns\n * {@link IValidation.IFailure} value with detailed error reasons. Otherwise,\n * there's no problem on the `input` value, Protocol Buffer binary data would be\n * stored in `data` property of the output {@link IValidation.ISuccess}\n * instance.\n *\n * If you can trust `input` value, or want to perform other type of validation,\n * use below functions instead.\n *\n * - {@link encode}\n * - {@link assertEncode}\n * - {@link isEncode}\n *\n * By the way, you know what? Expression power of Protocol Buffer is not enough\n * strong to fully meet the TypeScript type specs. In such reason, if you put a\n * TypeScript type that is not compatible with Protocol Buffer, this function\n * would throw compilation errors.\n *\n * - [Restrictions of Protocol\n *   Buffer](https://typia.io/docs/protobuf/message/#restrictions)\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Type of the value input\n * @param input A value to encode\n * @returns Encoded binary data\n */\nexport declare function validateEncode<T>(input: unknown): IValidation<Uint8Array>;\n/**\n * Creates a reusable {@link decode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createDecode(): never;\n/**\n * Creates a reusable {@link decode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @returns A reusable `decode` function\n */\nexport declare function createDecode<T>(): (input: Uint8Array) => Resolved<T>;\n/**\n * Creates a reusable {@link isDecode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsDecode(): never;\n/**\n * Creates a reusable {@link isDecode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @returns A reusable `isDecode` function\n */\nexport declare function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;\n/**\n * Creates a reusable {@link assertDecode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertDecode(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertDecode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertDecode` function\n */\nexport declare function createAssertDecode<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: Uint8Array) => Resolved<T>;\n/**\n * Creates a reusable {@link validateDecode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateDecode(): never;\n/**\n * Creates a reusable {@link validateDecode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @returns A reusable `validateDecode` function\n */\nexport declare function createValidateDecode<T>(): (input: Uint8Array) => IValidation<Resolved<T>>;\n/**\n * Creates a reusable {@link encode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createEncode(): never;\n/**\n * Creates a reusable {@link encode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @returns A reusable `encode` function\n */\nexport declare function createEncode<T>(): (input: T) => Uint8Array;\n/**\n * Creates a reusable {@link isEncode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createIsEncode(): never;\n/**\n * Creates a reusable {@link isEncode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @returns A reusable `isEncode` function\n */\nexport declare function createIsEncode<T>(): (input: T) => Uint8Array | null;\n/**\n * Creates a reusable {@link assertEncode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createAssertEncode(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): never;\n/**\n * Creates a reusable {@link assertEncode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @param errorFactory Custom error factory. Default is `TypeGuardError`\n * @returns A reusable `assertEncode` function\n */\nexport declare function createAssertEncode<T>(errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error)): (input: T) => Uint8Array;\n/**\n * Creates a reusable {@link validateEncode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns Nothing until you configure the generic argument `T`\n * @throws Compile error\n * @danger You must configure the generic argument `T`\n */\nexport declare function createValidateEncode(): never;\n/**\n * Creates a reusable {@link validateEncode} function.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template T Target type\n * @returns A reusable `validateEncode` function\n */\nexport declare function createValidateEncode<T>(): (input: T) => IValidation<Uint8Array>;\n",
   "node_modules/typia/lib/reflect.d.ts": "import { IMetadataApplication } from \"./schemas/metadata/IMetadataApplication\";\n/**\n * > You must configure the generic argument `Types`.\n *\n * Metadata Application.\n *\n * Creates a Metadata application which contains the metadata and components.\n *\n * Note that, all of the collection types like Array, Tuple and Objects are\n * stored in the {@link IMetadataApplication.components} property. Also, alias\n * types are stored in the {@link IMetadataApplication.aliases} property, too.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Types Tuple of target types\n * @returns Metadata application\n */\nexport declare function metadata(): never;\n/**\n * Metadata Application.\n *\n * Creates a Metadata application which contains the metadata and components.\n *\n * Note that, all of the collection types like Array, Tuple and Objects are\n * stored in the {@link IMetadataApplication.components} property. Also, alias\n * types are stored in the {@link IMetadataApplication.aliases} property, too.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @template Types Tuple of target types\n * @returns Metadata application\n */\nexport declare function metadata<Types extends unknown[]>(): IMetadataApplication;\nexport declare function name<T, Regular extends boolean = false>(): string;\nexport declare function name(): never;\n",
-  "node_modules/typia/lib/schemas/json/IJsonApplication.d.ts": "import { IJsonSchemaCollection } from \"./IJsonSchemaCollection\";\n/**\n * Collection of JSON schemas.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @deprecated Use {@link IJsonSchemaCollection} instead please. This interface\n *   type would be changed to {@link ILlmApplication} like structure in the\n *   future version (maybe next v8 major update).\n * @template Version Version of the OpenAPI specification.\n * @template Types Original TypeScript types used in the JSON schemas.\n */\nexport type IJsonApplication = IJsonSchemaCollection;\nexport declare namespace IJsonApplication {\n    type IV3_0 = IJsonSchemaCollection.IV3_0;\n    type IV3_1 = IJsonSchemaCollection.IV3_1;\n}\n",
+  "node_modules/typia/lib/schemas/json/IJsonSchemaApplication.d.ts": "import { OpenApi, OpenApiV3 } from \"@samchon/openapi\";\nexport interface IJsonSchemaApplication<Version extends \"3.0\" | \"3.1\" = \"3.1\", App extends any = object> {\n    version: Version;\n    components: IJsonSchemaApplication.IComponents<IJsonSchemaApplication.Schema<Version>>;\n    functions: IJsonSchemaApplication.IFunction<IJsonSchemaApplication.Schema<Version>>[];\n    __application?: App | undefined;\n}\nexport declare namespace IJsonSchemaApplication {\n    type Schema<Version extends \"3.0\" | \"3.1\"> = Version extends \"3.1\" ? OpenApi.IJsonSchema : OpenApiV3.IJsonSchema;\n    interface IComponents<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {\n        schemas?: Record<string, Schema>;\n    }\n    interface IFunction<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {\n        async: boolean;\n        name: string;\n        parameters: IParameter<Schema>[];\n        output: IOutput<Schema> | undefined;\n        summary?: string | undefined;\n        description?: string | undefined;\n        deprecated?: boolean;\n        tags?: string[];\n    }\n    interface IParameter<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {\n        name: string;\n        required: boolean;\n        schema: Schema;\n        title?: string | undefined;\n        description?: string | undefined;\n    }\n    interface IOutput<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {\n        schema: Schema;\n        required: boolean;\n        description?: string | undefined;\n    }\n}\n",
   "node_modules/typia/lib/schemas/json/IJsonSchemaCollection.d.ts": "import type { OpenApi, OpenApiV3 } from \"@samchon/openapi\";\n/**\n * Collection of JSON schemas with OpenAPI specification support.\n *\n * `IJsonSchemaCollection` represents a comprehensive collection of JSON schemas\n * that can be generated from TypeScript types using the `typia.json.schemas()`\n * function. This interface supports both OpenAPI v3.0 and v3.1 specifications,\n * with the ability to automatically generate appropriate schema definitions\n * based on the specified version.\n *\n * The collection includes:\n *\n * - Generated JSON schemas array containing schema definitions for the specified\n *   types\n * - Reusable components that can be referenced across different schemas\n * - Version-specific formatting that adheres to either OpenAPI v3.0 or v3.1\n *   standards\n *\n * Key differences between versions:\n *\n * - OpenAPI v3.0: Uses {@link OpenApiV3.IJsonSchema} format with limited tuple\n *   support\n * - OpenAPI v3.1: Uses {@link OpenApi.IJsonSchema} format with full JSON Schema\n *   Draft 2020-12 compatibility\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @example\n *   ```typescript\n *   // Generate schemas for OpenAPI v3.1 (default)\n *   const schemas = typia.json.schemas<[User, Product]>();\n *   // Type: IJsonSchemaCollection<\"3.1\", [User, Product]>\n *\n *   // Generate schemas for OpenAPI v3.0 (Swagger compatibility)\n *   const swaggerSchemas = typia.json.schemas<[User, Product], \"3.0\">();\n *   // Type: IJsonSchemaCollection<\"3.0\", [User, Product]>\n *   ```;\n *\n * @template Version The OpenAPI specification version to target (\"3.0\" or\n *   \"3.1\"). Defaults to \"3.1\" for enhanced JSON Schema compatibility.\n * @template Types Array of original TypeScript types that were analyzed to\n *   generate the JSON schemas. This provides type safety and traceability back\n *   to the source TypeScript definitions.\n */\nexport type IJsonSchemaCollection<Version extends \"3.0\" | \"3.1\" = \"3.1\", Types = unknown[]> = Version extends \"3.0\" ? IJsonSchemaCollection.IV3_0<Types> : IJsonSchemaCollection.IV3_1<Types>;\nexport declare namespace IJsonSchemaCollection {\n    /**\n     * JSON Schema collection formatted for OpenAPI v3.0 specification.\n     *\n     * This interface represents a collection of JSON schemas that comply with\n     * OpenAPI v3.0 standards, which are compatible with Swagger tools and legacy\n     * OpenAPI implementations. OpenAPI v3.0 has some limitations compared to\n     * v3.1, particularly around tuple types and pattern properties.\n     *\n     * Key characteristics of v3.0:\n     *\n     * - Cannot express tuple types natively (falls back to array representations)\n     * - Cannot express pattern properties in object schemas\n     * - Uses nullable property instead of union with null type\n     * - Limited JSON Schema Draft compatibility (based on Draft 4)\n     *\n     * @template Types Array of original TypeScript types used to generate the\n     *   schemas. This provides compile-time type information about what types\n     *   were analyzed during schema generation.\n     */\n    interface IV3_0<Types = unknown[]> {\n        /**\n         * OpenAPI specification version identifier.\n         *\n         * Always set to \"3.0\" to indicate this collection uses OpenAPI v3.0 schema\n         * format and constraints.\n         */\n        version: \"3.0\";\n        /**\n         * Array of generated JSON schemas.\n         *\n         * Contains the actual JSON schema definitions generated from the input\n         * TypeScript types. Each schema in this array corresponds to one of the\n         * types specified in the `Types` template parameter. The schemas follow\n         * OpenAPI v3.0 format and may contain references to components defined in\n         * the {@link components} property.\n         *\n         * Schema references typically use the format: `{ \"$ref\":\n         * \"#/components/schemas/TypeName\" }`\n         */\n        schemas: OpenApiV3.IJsonSchema[];\n        /**\n         * Reusable schema components for OpenAPI v3.0.\n         *\n         * Contains reusable schema definitions, security schemes, and other\n         * components that can be referenced from the main schemas. This follows the\n         * OpenAPI v3.0 components structure and enables schema reuse and\n         * modularity.\n         *\n         * Components include:\n         *\n         * - Schemas: Named type definitions that can be referenced via $ref\n         * - SecuritySchemes: Authentication and authorization schemes\n         * - Parameters: Reusable parameter definitions\n         * - RequestBodies: Reusable request body definitions\n         * - Responses: Reusable response definitions\n         * - Headers: Reusable header definitions\n         * - Examples: Reusable example definitions\n         */\n        components: OpenApiV3.IComponents;\n        /**\n         * Type metadata for compile-time type tracking.\n         *\n         * This optional property stores the original TypeScript types that were\n         * used to generate the JSON schemas. It's primarily used for type safety\n         * and doesn't affect runtime behavior. The property is marked as optional\n         * and undefined to prevent it from appearing in serialized JSON output.\n         *\n         * This enables:\n         *\n         * - Compile-time type checking against the original types\n         * - IDE intellisense and autocompletion\n         * - Type-safe schema validation and usage\n         */\n        __types?: Types | undefined;\n    }\n    /**\n     * JSON Schema collection formatted for OpenAPI v3.1 specification.\n     *\n     * This interface represents a collection of JSON schemas that comply with\n     * OpenAPI v3.1 standards, which provide enhanced JSON Schema compatibility\n     * and support for modern JSON Schema features. OpenAPI v3.1 is based on JSON\n     * Schema Draft 2020-12 and offers significant improvements over v3.0.\n     *\n     * Key advantages of v3.1:\n     *\n     * - Full tuple type support with prefixItems\n     * - Pattern properties support for dynamic object keys\n     * - Proper null type handling via union types\n     * - Enhanced JSON Schema Draft 2020-12 compatibility\n     * - Better const, enum, and validation support\n     *\n     * @template Types Array of original TypeScript types used to generate the\n     *   schemas. This provides compile-time type information about what types\n     *   were analyzed during schema generation.\n     */\n    interface IV3_1<Types = unknown[]> {\n        /**\n         * OpenAPI specification version identifier.\n         *\n         * Always set to \"3.1\" to indicate this collection uses OpenAPI v3.1 schema\n         * format with enhanced JSON Schema compatibility.\n         */\n        version: \"3.1\";\n        /**\n         * Reusable schema components for OpenAPI v3.1.\n         *\n         * Contains reusable schema definitions and other components following the\n         * OpenAPI v3.1 specification. This structure is similar to v3.0 but\n         * supports enhanced JSON Schema features and improved type definitions.\n         *\n         * Components include:\n         *\n         * - Schemas: Named type definitions with enhanced JSON Schema support\n         * - SecuritySchemes: Authentication and authorization schemes\n         *\n         * The emended OpenAPI v3.1 format used here removes ambiguous expressions\n         * and standardizes certain patterns for better tooling compatibility.\n         */\n        components: OpenApi.IComponents;\n        /**\n         * Array of generated JSON schemas with v3.1 enhancements.\n         *\n         * Contains JSON schema definitions that take advantage of OpenAPI v3.1's\n         * enhanced capabilities. These schemas can express more complex TypeScript\n         * types accurately, including:\n         *\n         * - Tuple types using prefixItems\n         * - Union types with proper null handling\n         * - Complex nested object structures\n         * - Pattern-based property definitions\n         *\n         * Each schema corresponds to one of the input TypeScript types and may\n         * reference components defined in the {@link components} property.\n         */\n        schemas: OpenApi.IJsonSchema[];\n        /**\n         * Type metadata for compile-time type tracking.\n         *\n         * This optional property stores the original TypeScript types that were\n         * used to generate the JSON schemas. It provides compile-time type safety\n         * and enables better development experience without affecting runtime\n         * behavior.\n         *\n         * Benefits include:\n         *\n         * - Strong typing connection to original TypeScript definitions\n         * - Enhanced IDE support and autocompletion\n         * - Compile-time validation of schema usage\n         * - Type-safe integration with validation libraries\n         */\n        __types?: Types | undefined;\n    }\n}\n",
   "node_modules/typia/lib/schemas/json/IJsonSchemaUnit.d.ts": "import { OpenApi, OpenApiV3 } from \"@samchon/openapi\";\n/**\n * Single unit of JSON schema representation.\n *\n * `IJsonSchemaUnit` represents a self-contained JSON schema unit that\n * encapsulates a single schema definition along with its associated reusable\n * components. This is typically used when generating a JSON schema for a single\n * TypeScript type, as opposed to a collection of multiple types.\n *\n * Unlike {@link IJsonSchemaCollection} which handles multiple schemas,\n * `IJsonSchemaUnit` focuses on representing a single schema with its\n * dependencies. This makes it ideal for scenarios where you need to work with\n * individual type definitions or when integrating with systems that expect\n * single schema documents.\n *\n * The unit contains:\n *\n * - A single JSON schema definition for the specified TypeScript type\n * - All necessary reusable components that the schema may reference\n * - Version-specific formatting for either OpenAPI v3.0 or v3.1 compatibility\n * - Optional type metadata for compile-time type safety\n *\n * Key differences from collection:\n *\n * - Contains only one schema instead of an array of schemas\n * - More lightweight for single-type use cases\n * - Simpler structure for direct schema consumption\n * - Still maintains full component reference support\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @example\n *   ```typescript\n *   interface User {\n *     id: string;\n *     name: string;\n *     email?: string;\n *   }\n *\n *   // Generate a single schema unit for OpenAPI v3.1 (default)\n *   const userSchema = typia.json.schema<User>();\n *   // Type: IJsonSchemaUnit<\"3.1\", User>\n *\n *   // Generate a single schema unit for OpenAPI v3.0 (Swagger compatibility)\n *   const swaggerUserSchema = typia.json.schema<User, \"3.0\">();\n *   // Type: IJsonSchemaUnit<\"3.0\", User>\n *   ```;\n *\n * @template Version The OpenAPI specification version to target (\"3.0\" or\n *   \"3.1\"). Defaults to \"3.1\" for enhanced JSON Schema Draft 2020-12\n *   compatibility. This determines the schema format, validation capabilities,\n *   and available features like tuple support and null type handling.\n * @template Type The original TypeScript type that was analyzed to generate\n *   this JSON schema unit. This provides compile-time type safety and enables\n *   IDEs to provide better intellisense and validation.\n * @see {@link IJsonSchemaCollection} For handling multiple schemas at once\n */\nexport type IJsonSchemaUnit<Version extends \"3.0\" | \"3.1\" = \"3.1\", Type = unknown> = Version extends \"3.0\" ? IJsonSchemaUnit.IV3_0<Type> : IJsonSchemaUnit.IV3_1<Type>;\nexport declare namespace IJsonSchemaUnit {\n    /**\n     * JSON Schema unit formatted for OpenAPI v3.0 specification.\n     *\n     * This interface represents a single JSON schema unit that complies with\n     * OpenAPI v3.0 standards. It contains one schema definition along with any\n     * reusable components that the schema references, formatted according to\n     * OpenAPI v3.0 constraints and limitations.\n     *\n     * OpenAPI v3.0 characteristics affecting this unit:\n     *\n     * - Schema follows OpenAPI v3.0 JSON Schema subset\n     * - Limited support for advanced JSON Schema features\n     * - Uses nullable property for optional null values\n     * - Cannot natively express tuple types or pattern properties\n     * - Based on JSON Schema Draft 4 with OpenAPI-specific extensions\n     *\n     * Use cases for v3.0:\n     *\n     * - Integration with legacy Swagger tooling\n     * - Compatibility with older OpenAPI implementations\n     * - Systems that specifically require OpenAPI v3.0 format\n     * - Code generation tools that expect v3.0 schemas\n     *\n     * @template Type The original TypeScript type represented by this schema\n     *   unit. Provides compile-time type information and enables type-safe\n     *   operations on the schema.\n     */\n    interface IV3_0<Type> {\n        /**\n         * OpenAPI specification version identifier.\n         *\n         * Always set to \"3.0\" to indicate this schema unit uses OpenAPI v3.0 format\n         * and adheres to its specific constraints and limitations.\n         */\n        version: \"3.0\";\n        /**\n         * The primary JSON schema definition.\n         *\n         * Contains the main JSON schema that represents the TypeScript type\n         * specified in the `Type` template parameter. This schema follows OpenAPI\n         * v3.0 format and may contain references to reusable components defined in\n         * the {@link components} property.\n         *\n         * The schema structure includes:\n         *\n         * - Type definitions following OpenAPI v3.0 constraints\n         * - Property definitions with v3.0-compatible validation rules\n         * - References to shared components using $ref syntax\n         * - Nullable properties for optional fields that can be null\n         *\n         * Example schema reference: `{ \"$ref\": \"#/components/schemas/NestedType\" }`\n         */\n        schema: OpenApiV3.IJsonSchema;\n        /**\n         * Reusable schema components for OpenAPI v3.0.\n         *\n         * Contains all reusable schema definitions and components that may be\n         * referenced by the main schema. This enables schema modularity and\n         * prevents duplication when the same types are used in multiple places\n         * within the schema definition.\n         *\n         * Component categories include:\n         *\n         * - Schemas: Named type definitions for complex objects, arrays, and unions\n         * - SecuritySchemes: Authentication and authorization definitions\n         * - Parameters: Reusable parameter specifications\n         * - RequestBodies: Reusable request body definitions\n         * - Responses: Reusable response specifications\n         * - Headers: Reusable header definitions\n         * - Examples: Reusable example values\n         *\n         * All components follow OpenAPI v3.0 format restrictions and capabilities.\n         */\n        components: OpenApiV3.IComponents;\n        /**\n         * Type metadata for compile-time type safety.\n         *\n         * This optional property maintains a reference to the original TypeScript\n         * type that was used to generate this schema unit. It provides compile-time\n         * type information without affecting the runtime JSON representation.\n         *\n         * Benefits of type metadata:\n         *\n         * - Enables type-safe schema validation and usage\n         * - Provides IDE intellisense and autocompletion\n         * - Allows compile-time checking of schema operations\n         * - Maintains traceability to original TypeScript definitions\n         *\n         * The property is intentionally marked as optional and undefined to ensure\n         * it doesn't appear in serialized JSON output while preserving type\n         * information at compile time.\n         */\n        __type?: Type | undefined;\n    }\n    /**\n     * JSON Schema unit formatted for OpenAPI v3.1 specification.\n     *\n     * This interface represents a single JSON schema unit that takes advantage of\n     * OpenAPI v3.1's enhanced capabilities and improved JSON Schema\n     * compatibility. It provides a more feature-rich and accurate representation\n     * of TypeScript types compared to the v3.0 format.\n     *\n     * OpenAPI v3.1 advantages for this unit:\n     *\n     * - Full JSON Schema Draft 2020-12 compatibility\n     * - Native tuple type support using prefixItems\n     * - Proper null type handling via union types\n     * - Pattern properties for dynamic object keys\n     * - Enhanced const, enum, and validation capabilities\n     * - Better support for complex nested structures\n     *\n     * Use cases for v3.1:\n     *\n     * - Modern OpenAPI implementations and tooling\n     * - Systems requiring accurate TypeScript type representation\n     * - Applications needing advanced JSON Schema features\n     * - New projects without legacy compatibility requirements\n     *\n     * @template Type The original TypeScript type represented by this schema\n     *   unit. Enables compile-time type safety and provides enhanced development\n     *   experience with better IDE support.\n     */\n    interface IV3_1<Type> {\n        /**\n         * OpenAPI specification version identifier.\n         *\n         * Always set to \"3.1\" to indicate this schema unit uses OpenAPI v3.1 format\n         * with enhanced JSON Schema compatibility and modern features.\n         */\n        version: \"3.1\";\n        /**\n         * The primary JSON schema definition with v3.1 enhancements.\n         *\n         * Contains the main JSON schema that accurately represents the TypeScript\n         * type using OpenAPI v3.1's enhanced capabilities. This schema can express\n         * complex TypeScript constructs that were not possible or accurate in\n         * v3.0.\n         *\n         * Enhanced schema features include:\n         *\n         * - Tuple types using prefixItems for exact array structure\n         * - Union types with proper null handling via oneOf\n         * - Const values for literal types\n         * - Pattern properties for Record<string, T> types\n         * - Advanced validation constraints and metadata\n         * - Recursive type definitions with proper $ref handling\n         *\n         * The schema follows the emended OpenAPI v3.1 format used by typia, which\n         * removes ambiguous expressions while maintaining full compatibility.\n         */\n        schema: OpenApi.IJsonSchema;\n        /**\n         * Reusable schema components for OpenAPI v3.1.\n         *\n         * Contains reusable schema definitions and components that leverage OpenAPI\n         * v3.1's enhanced capabilities. These components provide better type\n         * representation and more accurate schema definitions compared to v3.0.\n         *\n         * Enhanced component features:\n         *\n         * - Schemas: More accurate type definitions with v3.1 JSON Schema features\n         * - SecuritySchemes: Enhanced authentication scheme definitions\n         * - Better support for complex nested references\n         * - Improved handling of recursive and circular type dependencies\n         *\n         * The components structure follows the emended OpenAPI v3.1 specification\n         * that simplifies certain patterns while maintaining full expressiveness.\n         */\n        components: OpenApi.IComponents;\n        /**\n         * Type metadata for enhanced compile-time type safety.\n         *\n         * This optional property preserves the original TypeScript type information\n         * for compile-time type checking and enhanced development experience. It\n         * enables type-safe operations and better IDE support without affecting the\n         * runtime JSON schema representation.\n         *\n         * Enhanced type safety features:\n         *\n         * - Strong typing connection to original TypeScript definitions\n         * - Better IDE intellisense and error detection\n         * - Compile-time validation of schema usage patterns\n         * - Type-safe integration with validation and serialization libraries\n         * - Enhanced debugging and development experience\n         *\n         * The property remains optional and undefined to maintain clean JSON\n         * serialization while preserving valuable compile-time information.\n         */\n        __type?: Type | undefined;\n    }\n}\n",
-  "node_modules/typia/lib/schemas/json/__IJsonApplication.d.ts": "import { OpenApi, OpenApiV3 } from \"@samchon/openapi\";\nexport interface __IJsonApplication<Version extends \"3.0\" | \"3.1\" = \"3.1\", App extends any = object> {\n    version: Version;\n    components: __IJsonApplication.IComponents<__IJsonApplication.Schema<Version>>;\n    functions: __IJsonApplication.IFunction<__IJsonApplication.Schema<Version>>[];\n    __application?: App | undefined;\n}\nexport declare namespace __IJsonApplication {\n    type Schema<Version extends \"3.0\" | \"3.1\"> = Version extends \"3.1\" ? OpenApi.IJsonSchema : OpenApiV3.IJsonSchema;\n    interface IComponents<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {\n        schemas?: Record<string, Schema>;\n    }\n    interface IFunction<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {\n        async: boolean;\n        name: string;\n        parameters: IParameter<Schema>[];\n        output: IOutput<Schema> | undefined;\n        summary?: string | undefined;\n        description?: string | undefined;\n        deprecated?: boolean;\n        tags?: string[];\n    }\n    interface IParameter<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {\n        name: string;\n        required: boolean;\n        schema: Schema;\n        title?: string | undefined;\n        description?: string | undefined;\n    }\n    interface IOutput<Schema extends OpenApi.IJsonSchema | OpenApiV3.IJsonSchema = OpenApi.IJsonSchema> {\n        schema: Schema;\n        required: boolean;\n        description?: string | undefined;\n    }\n}\n",
   "node_modules/typia/lib/schemas/metadata/IJsDocTagInfo.d.ts": "export interface IJsDocTagInfo {\n    name: string;\n    text?: IJsDocTagInfo.IText[];\n}\nexport declare namespace IJsDocTagInfo {\n    interface IText {\n        text: string;\n        kind: string;\n    }\n}\n",
   "node_modules/typia/lib/schemas/metadata/IMetadata.d.ts": "import { IMetadataAlias } from \"./IMetadataAlias\";\nimport { IMetadataArray } from \"./IMetadataArray\";\nimport { IMetadataAtomic } from \"./IMetadataAtomic\";\nimport { IMetadataConstant } from \"./IMetadataConstant\";\nimport { IMetadataEscaped } from \"./IMetadataEscaped\";\nimport { IMetadataFunction } from \"./IMetadataFunction\";\nimport { IMetadataMap } from \"./IMetadataMap\";\nimport { IMetadataNative } from \"./IMetadataNative\";\nimport { IMetadataObject } from \"./IMetadataObject\";\nimport { IMetadataSet } from \"./IMetadataSet\";\nimport { IMetadataTemplate } from \"./IMetadataTemplate\";\nimport { IMetadataTuple } from \"./IMetadataTuple\";\nexport interface IMetadata {\n    any: boolean;\n    required: boolean;\n    optional: boolean;\n    nullable: boolean;\n    functions: IMetadataFunction[];\n    atomics: IMetadataAtomic[];\n    constants: IMetadataConstant[];\n    templates: IMetadataTemplate[];\n    escaped: IMetadataEscaped | null;\n    rest: IMetadata | null;\n    arrays: IMetadataArray[];\n    tuples: IMetadataTuple[];\n    objects: IMetadataObject[];\n    aliases: IMetadataAlias[];\n    natives: IMetadataNative[];\n    sets: IMetadataSet[];\n    maps: IMetadataMap[];\n}\n",
   "node_modules/typia/lib/schemas/metadata/IMetadataAlias.d.ts": "import { IMetadataTypeTag } from \"./IMetadataTypeTag\";\nexport interface IMetadataAlias {\n    name: string;\n    tags: IMetadataTypeTag[][];\n}\n",
@@ -1119,7 +1118,7 @@
   "node_modules/typia/lib/transformers/features/http/HttpValidateFormDataTransformer.d.ts": "import { ITransformProps } from \"../../ITransformProps\";\nexport declare namespace HttpValidateFormDataTransformer {\n    const transform: (props: ITransformProps) => import(\"typescript\").CallExpression;\n}\n",
   "node_modules/typia/lib/transformers/features/http/HttpValidateHeadersTransformer.d.ts": "import { ITransformProps } from \"../../ITransformProps\";\nexport declare namespace HttpValidateHeadersTransformer {\n    const transform: (props: ITransformProps) => import(\"typescript\").CallExpression;\n}\n",
   "node_modules/typia/lib/transformers/features/http/HttpValidateQueryTransformer.d.ts": "import { ITransformProps } from \"../../ITransformProps\";\nexport declare namespace HttpValidateQueryTransformer {\n    const transform: (props: ITransformProps) => import(\"typescript\").CallExpression;\n}\n",
-  "node_modules/typia/lib/transformers/features/json/JsonApplicationTransformer.d.ts": "",
+  "node_modules/typia/lib/transformers/features/json/JsonApplicationTransformer.d.ts": "import ts from \"typescript\";\nimport { ITransformProps } from \"../../ITransformProps\";\nexport declare namespace JsonApplicationTransformer {\n    const transform: (props: ITransformProps) => ts.Expression;\n}\n",
   "node_modules/typia/lib/transformers/features/json/JsonAssertParseTransformer.d.ts": "import { ITransformProps } from \"../../ITransformProps\";\nexport declare namespace JsonAssertParseTransformer {\n    const transform: (props: ITransformProps) => import(\"typescript\").CallExpression;\n}\n",
   "node_modules/typia/lib/transformers/features/json/JsonAssertStringifyTransformer.d.ts": "import { ITransformProps } from \"../../ITransformProps\";\nexport declare namespace JsonAssertStringifyTransformer {\n    const transform: (props: ITransformProps) => import(\"typescript\").CallExpression;\n}\n",
   "node_modules/typia/lib/transformers/features/json/JsonCreateAssertParseTransformer.d.ts": "import { ITransformProps } from \"../../ITransformProps\";\nexport declare namespace JsonCreateAssertParseTransformer {\n    const transform: (props: ITransformProps) => import(\"typescript\").Expression | import(\"typescript\").ArrowFunction;\n}\n",
@@ -1205,7 +1204,7 @@
   "node_modules/typia/lib/utils/ProtobufNameEncoder.d.ts": "export declare namespace ProtobufNameEncoder {\n    const encode: (str: string) => string;\n    const decode: (str: string) => string;\n}\n",
   "node_modules/typia/lib/utils/Singleton.d.ts": "export declare class Singleton<T, Args extends any[] = []> {\n    private readonly closure_;\n    private value_;\n    constructor(closure: (...args: Args) => T);\n    get(...args: Args): T;\n}\n",
   "node_modules/typia/lib/utils/StringUtil.d.ts": "export declare namespace StringUtil {\n    const capitalize: (str: string) => string;\n    const escapeDuplicate: (props: {\n        keep: string[];\n        input: string;\n        escape?: (str: string) => string;\n    }) => string;\n}\n",
-  "node_modules/typia/package.json": "{\n  \"name\": \"typia\",\n  \"version\": \"10.0.0\",\n  \"description\": \"Superfast runtime validators with only one line\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"module\": \"lib/index.mjs\",\n  \"bin\": {\n    \"typia\": \"./lib/executable/typia.js\"\n  },\n  \"tsp\": {\n    \"tscOptions\": {\n      \"parseAllJsDoc\": true\n    }\n  },\n  \"scripts\": {\n    \"test\": \"ts-node deploy --tag test\",\n    \"test:template\": \"npm run --tag test --template\",\n    \"-------------------------------------------------\": \"\",\n    \"build\": \"rimraf lib && tsc && rollup -c\",\n    \"dev\": \"rimraf lib && tsc --watch\",\n    \"dev:errors\": \"tsc --project tsconfig.errors.json --watch\",\n    \"eslint\": \"eslint\",\n    \"eslint:fix\": \"eslint --fix\",\n    \"prettier\": \"prettier src --check\",\n    \"prettier:fix\": \"prettier src --write\",\n    \"------------------------------------------------\": \"\",\n    \"package:latest\": \"ts-node deploy --tag latest\",\n    \"package:next\": \"ts-node deploy --tag next\",\n    \"package:patch\": \"ts-node deploy --tag patch\",\n    \"package:tgz\": \"ts-node deploy/tgz.ts\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/typia\"\n  },\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/typia/issues\"\n  },\n  \"homepage\": \"https://typia.io\",\n  \"dependencies\": {\n    \"@samchon/openapi\": \"^5.0.0\",\n    \"@standard-schema/spec\": \"^1.0.0\",\n    \"commander\": \"^10.0.0\",\n    \"comment-json\": \"^4.2.3\",\n    \"inquirer\": \"^8.2.5\",\n    \"package-manager-detector\": \"^0.2.0\",\n    \"randexp\": \"^0.5.3\"\n  },\n  \"peerDependencies\": {\n    \"typescript\": \">=4.8.0 <5.10.0\"\n  },\n  \"devDependencies\": {\n    \"@rollup/plugin-commonjs\": \"^26.0.1\",\n    \"@rollup/plugin-node-resolve\": \"^15.2.3\",\n    \"@rollup/plugin-typescript\": \"^11.1.6\",\n    \"@trivago/prettier-plugin-sort-imports\": \"^4.3.0\",\n    \"@types/inquirer\": \"^8.2.5\",\n    \"@types/node\": \"^18.15.12\",\n    \"@types/ts-expose-internals\": \"npm:ts-expose-internals@5.6.3\",\n    \"@typescript-eslint/eslint-plugin\": \"^8.1.0\",\n    \"@typescript-eslint/parser\": \"^8.1.0\",\n    \"chalk\": \"^4.0.0\",\n    \"eslint-plugin-deprecation\": \"^3.0.0\",\n    \"prettier\": \"^3.2.5\",\n    \"prettier-plugin-jsdoc\": \"^1.3.3\",\n    \"rimraf\": \"^5.0.5\",\n    \"rollup\": \"^4.18.0\",\n    \"rollup-plugin-auto-external\": \"^2.0.0\",\n    \"rollup-plugin-node-externals\": \"^8.0.0\",\n    \"suppress-warnings\": \"^1.0.2\",\n    \"tinyglobby\": \"^0.2.12\",\n    \"ts-node\": \"^10.9.2\",\n    \"typescript\": \"~5.9.3\"\n  },\n  \"sideEffects\": false,\n  \"files\": [\n    \"LICENSE\",\n    \"README.md\",\n    \"package.json\",\n    \"lib\",\n    \"src\"\n  ],\n  \"keywords\": [\n    \"fast\",\n    \"json\",\n    \"stringify\",\n    \"typescript\",\n    \"transform\",\n    \"ajv\",\n    \"io-ts\",\n    \"zod\",\n    \"schema\",\n    \"json-schema\",\n    \"generator\",\n    \"assert\",\n    \"clone\",\n    \"is\",\n    \"validate\",\n    \"equal\",\n    \"runtime\",\n    \"type\",\n    \"typebox\",\n    \"checker\",\n    \"validator\",\n    \"safe\",\n    \"parse\",\n    \"prune\",\n    \"random\",\n    \"protobuf\",\n    \"llm\",\n    \"llm-function-calling\",\n    \"structured-output\",\n    \"openai\",\n    \"chatgpt\",\n    \"claude\",\n    \"gemini\",\n    \"llama\"\n  ]\n}",
+  "node_modules/typia/package.json": "{\n  \"name\": \"typia\",\n  \"version\": \"10.0.2\",\n  \"description\": \"Superfast runtime validators with only one line\",\n  \"main\": \"lib/index.js\",\n  \"typings\": \"lib/index.d.ts\",\n  \"module\": \"lib/index.mjs\",\n  \"bin\": {\n    \"typia\": \"./lib/executable/typia.js\"\n  },\n  \"tsp\": {\n    \"tscOptions\": {\n      \"parseAllJsDoc\": true\n    }\n  },\n  \"scripts\": {\n    \"test\": \"ts-node deploy --tag test\",\n    \"test:template\": \"npm run --tag test --template\",\n    \"-------------------------------------------------\": \"\",\n    \"build\": \"rimraf lib && tsc && rollup -c\",\n    \"dev\": \"rimraf lib && tsc --watch\",\n    \"dev:errors\": \"tsc --project tsconfig.errors.json --watch\",\n    \"eslint\": \"eslint\",\n    \"eslint:fix\": \"eslint --fix\",\n    \"prettier\": \"prettier src --check\",\n    \"prettier:fix\": \"prettier src --write\",\n    \"------------------------------------------------\": \"\",\n    \"package:latest\": \"ts-node deploy --tag latest\",\n    \"package:next\": \"ts-node deploy --tag next\",\n    \"package:patch\": \"ts-node deploy --tag patch\",\n    \"package:tgz\": \"ts-node deploy/tgz.ts\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/samchon/typia\"\n  },\n  \"author\": \"Jeongho Nam\",\n  \"license\": \"MIT\",\n  \"bugs\": {\n    \"url\": \"https://github.com/samchon/typia/issues\"\n  },\n  \"homepage\": \"https://typia.io\",\n  \"dependencies\": {\n    \"@samchon/openapi\": \"^5.0.1\",\n    \"@standard-schema/spec\": \"^1.0.0\",\n    \"commander\": \"^10.0.0\",\n    \"comment-json\": \"^4.2.3\",\n    \"inquirer\": \"^8.2.5\",\n    \"package-manager-detector\": \"^0.2.0\",\n    \"randexp\": \"^0.5.3\"\n  },\n  \"peerDependencies\": {\n    \"typescript\": \">=4.8.0 <5.10.0\"\n  },\n  \"devDependencies\": {\n    \"@rollup/plugin-commonjs\": \"^26.0.1\",\n    \"@rollup/plugin-node-resolve\": \"^15.2.3\",\n    \"@rollup/plugin-typescript\": \"^11.1.6\",\n    \"@trivago/prettier-plugin-sort-imports\": \"^4.3.0\",\n    \"@types/inquirer\": \"^8.2.5\",\n    \"@types/node\": \"^18.15.12\",\n    \"@types/ts-expose-internals\": \"npm:ts-expose-internals@5.6.3\",\n    \"@typescript-eslint/eslint-plugin\": \"^8.1.0\",\n    \"@typescript-eslint/parser\": \"^8.1.0\",\n    \"chalk\": \"^4.0.0\",\n    \"eslint-plugin-deprecation\": \"^3.0.0\",\n    \"prettier\": \"^3.2.5\",\n    \"prettier-plugin-jsdoc\": \"^1.3.3\",\n    \"rimraf\": \"^5.0.5\",\n    \"rollup\": \"^4.18.0\",\n    \"rollup-plugin-auto-external\": \"^2.0.0\",\n    \"rollup-plugin-node-externals\": \"^8.0.0\",\n    \"suppress-warnings\": \"^1.0.2\",\n    \"tinyglobby\": \"^0.2.12\",\n    \"ts-node\": \"^10.9.2\",\n    \"typescript\": \"~5.9.3\"\n  },\n  \"sideEffects\": false,\n  \"files\": [\n    \"LICENSE\",\n    \"README.md\",\n    \"package.json\",\n    \"lib\",\n    \"src\"\n  ],\n  \"keywords\": [\n    \"fast\",\n    \"json\",\n    \"stringify\",\n    \"typescript\",\n    \"transform\",\n    \"ajv\",\n    \"io-ts\",\n    \"zod\",\n    \"schema\",\n    \"json-schema\",\n    \"generator\",\n    \"assert\",\n    \"clone\",\n    \"is\",\n    \"validate\",\n    \"equal\",\n    \"runtime\",\n    \"type\",\n    \"typebox\",\n    \"checker\",\n    \"validator\",\n    \"safe\",\n    \"parse\",\n    \"prune\",\n    \"random\",\n    \"protobuf\",\n    \"llm\",\n    \"llm-function-calling\",\n    \"structured-output\",\n    \"openai\",\n    \"chatgpt\",\n    \"claude\",\n    \"gemini\",\n    \"llama\"\n  ]\n}",
   "node_modules/undici-types/agent.d.ts": "import { URL } from 'url'\nimport Pool from './pool'\nimport Dispatcher from \"./dispatcher\";\n\nexport default Agent\n\ndeclare class Agent extends Dispatcher{\n  constructor(opts?: Agent.Options)\n  /** `true` after `dispatcher.close()` has been called. */\n  closed: boolean;\n  /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */\n  destroyed: boolean;\n  /** Dispatches a request. */\n  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;\n}\n\ndeclare namespace Agent {\n  export interface Options extends Pool.Options {\n    /** Default: `(origin, opts) => new Pool(origin, opts)`. */\n    factory?(origin: string | URL, opts: Object): Dispatcher;\n    /** Integer. Default: `0` */\n    maxRedirections?: number;\n\n    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options[\"interceptors\"]\n  }\n\n  export interface DispatchOptions extends Dispatcher.DispatchOptions {\n    /** Integer. */\n    maxRedirections?: number;\n  }\n}\n",
   "node_modules/undici-types/api.d.ts": "import { URL, UrlObject } from 'url'\nimport { Duplex } from 'stream'\nimport Dispatcher from './dispatcher'\n\nexport {\n  request,\n  stream,\n  pipeline,\n  connect,\n  upgrade,\n}\n\n/** Performs an HTTP request. */\ndeclare function request(\n  url: string | URL | UrlObject,\n  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,\n): Promise<Dispatcher.ResponseData>;\n\n/** A faster version of `request`. */\ndeclare function stream(\n  url: string | URL | UrlObject,\n  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path'>,\n  factory: Dispatcher.StreamFactory\n): Promise<Dispatcher.StreamData>;\n\n/** For easy use with `stream.pipeline`. */\ndeclare function pipeline(\n  url: string | URL | UrlObject,\n  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions, 'origin' | 'path'>,\n  handler: Dispatcher.PipelineHandler\n): Duplex;\n\n/** Starts two-way communications with the requested resource. */\ndeclare function connect(\n  url: string | URL | UrlObject,\n  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions, 'origin' | 'path'>\n): Promise<Dispatcher.ConnectData>;\n\n/** Upgrade to a different protocol. */\ndeclare function upgrade(\n  url: string | URL | UrlObject,\n  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>\n): Promise<Dispatcher.UpgradeData>;\n",
   "node_modules/undici-types/balanced-pool.d.ts": "import Pool from './pool'\nimport Dispatcher from './dispatcher'\nimport { URL } from 'url'\n\nexport default BalancedPool\n\ntype BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, \"origin\">;\n\ndeclare class BalancedPool extends Dispatcher {\n  constructor(url: string | string[] | URL | URL[], options?: Pool.Options);\n\n  addUpstream(upstream: string | URL): BalancedPool;\n  removeUpstream(upstream: string | URL): BalancedPool;\n  upstreams: Array<string>;\n\n  /** `true` after `pool.close()` has been called. */\n  closed: boolean;\n  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */\n  destroyed: boolean;\n\n  // Override dispatcher APIs.\n  override connect(\n    options: BalancedPoolConnectOptions\n  ): Promise<Dispatcher.ConnectData>;\n  override connect(\n    options: BalancedPoolConnectOptions,\n    callback: (err: Error | null, data: Dispatcher.ConnectData) => void\n  ): void;\n}\n",