typia 10.0.0 → 10.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "10.0.0",
+  "version": "10.0.2",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -41,7 +41,7 @@
   },
   "homepage": "https://typia.io",
   "dependencies": {
-    "@samchon/openapi": "^5.0.0",
+    "@samchon/openapi": "^5.0.1",
     "@standard-schema/spec": "^1.0.0",
     "commander": "^10.0.0",
     "comment-json": "^4.2.3",

package/src/json.ts

@@ -1,3 +1,4 @@
+import { IJsonSchemaApplication } from "./schemas/json/IJsonSchemaApplication";
 import { IJsonSchemaCollection } from "./schemas/json/IJsonSchemaCollection";
 import { IJsonSchemaUnit } from "./schemas/json/IJsonSchemaUnit";
 
@@ -16,6 +17,54 @@ import { TypeGuardError } from "./TypeGuardError";
 ==============================================================
     METADATA
 ----------------------------------------------------------- */
+/**
+ * > You must configure the generic argument `Type`.
+ *
+ * JSON schema generator.
+ *
+ * Creates a JSON schema unit which contains a main JSON schema and its
+ * components. Note that, all of the named types are stored in the
+ * {@link IJsonSchemaUnit.components} property for the `$ref` referencing.
+ *
+ * Also, you can specify the OpenAPI version by configuring the second generic
+ * argument `Version`. For reference, the default version is `"3.1"`, and key
+ * different of `"3.0"` and `"3.1"` is whether supporting the tuple type or
+ * not.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template Type Target type
+ * @template Version Version of OpenAPI specification. Default is 3.1
+ * @returns JSON schema unit
+ */
+export function schema(): never;
+
+/**
+ * JSON schema generator.
+ *
+ * Creates a JSON schema unit which contains a main JSON schema and its
+ * components. Note that, all of the named types are stored in the
+ * {@link IJsonSchemaUnit.components} property for the `$ref` referencing.
+ *
+ * Also, you can specify the OpenAPI version by configuring the second generic
+ * argument `Version`. For reference, the default version is `"3.1"`, and key
+ * different of `"3.0"` and `"3.1"` is whether supporting the tuple type or
+ * not.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template Type Target type
+ * @template Version Version of OpenAPI specification. Default is 3.1
+ * @returns JSON schema unit
+ */
+export function schema<
+  Type extends unknown,
+  Version extends "3.0" | "3.1" = "3.1",
+>(): IJsonSchemaUnit<Version, Type>;
+
+/** @internal */
+export function schema(): never {
+  NoTransformConfigurationError("json.schema");
+}
+
 /**
  * > You must configure the generic argument `Types`.
  *
@@ -65,51 +114,99 @@ export function schemas(): never {
 }
 
 /**
- * > You must configure the generic argument `Type`.
+ * > You must configure the generic argument `Class`.
  *
- * JSON schema generator.
+ * TypeScript class to JSON function schema application.
  *
- * Creates a JSON schema unit which contains a main JSON schema and its
- * components. Note that, all of the named types are stored in the
- * {@link IJsonSchemaUnit.components} property for the `$ref` referencing.
+ * Creates a JSON function schema application from a TypeScript class or
+ * interface type containing the target functions. This is an intermediate-level
+ * function designed for professional developers who want to build custom LLM
+ * function calling schemas or need to transform class methods into structured
+ * JSON schema representations.
+ *
+ * Unlike {@link schema} which creates a schema for a single type, this function
+ * analyzes an entire class/interface and generates JSON schemas for all its
+ * methods, their parameters, and return types. The returned
+ * {@link IJsonSchemaApplication} contains:
+ *
+ * - {@link IJsonSchemaApplication.functions}: Array of function metadata with
+ *   parameter and return type schemas
+ * - {@link IJsonSchemaApplication.components}: Shared schema components for `$ref`
+ *   referencing
+ *
+ * This function serves as the underlying implementation for
+ * {@link llm.application}, and can be used when you need to:
+ *
+ * - Create your own custom LLM function calling schema format
+ * - Transform class methods into structured JSON schema format
+ * - Build API documentation or code generation tools
+ * - Develop alternative LLM integrations beyond the built-in providers
+ *
+ * For direct LLM function calling implementations, consider using
+ * {@link llm.application} instead, which provides provider-specific schemas for
+ * ChatGPT, Claude, Gemini, and other LLM providers.
  *
  * Also, you can specify the OpenAPI version by configuring the second generic
- * argument `Version`. For reference, the default version is `"3.1"`, and key
- * different of `"3.0"` and `"3.1"` is whether supporting the tuple type or
- * not.
+ * argument `Version`. For reference, the default version is `"3.1"`, and the
+ * key difference between `"3.0"` and `"3.1"` is whether supporting the tuple
+ * type or not.
  *
  * @author Jeongho Nam - https://github.com/samchon
- * @template Type Target type
+ * @template Class Target class or interface type containing the functions
  * @template Version Version of OpenAPI specification. Default is 3.1
- * @returns JSON schema unit
+ * @returns JSON function schema application
  */
-export function schema(): never;
+export function application(): never;
 
 /**
- * JSON schema generator.
+ * TypeScript class to JSON function schema application.
  *
- * Creates a JSON schema unit which contains a main JSON schema and its
- * components. Note that, all of the named types are stored in the
- * {@link IJsonSchemaUnit.components} property for the `$ref` referencing.
+ * Creates a JSON function schema application from a TypeScript class or
+ * interface type containing the target functions. This is an intermediate-level
+ * function designed for professional developers who want to build custom LLM
+ * function calling schemas or need to transform class methods into structured
+ * JSON schema representations.
+ *
+ * Unlike {@link schema} which creates a schema for a single type, this function
+ * analyzes an entire class/interface and generates JSON schemas for all its
+ * methods, their parameters, and return types. The returned
+ * {@link IJsonSchemaApplication} contains:
+ *
+ * - {@link IJsonSchemaApplication.functions}: Array of function metadata with
+ *   parameter and return type schemas
+ * - {@link IJsonSchemaApplication.components}: Shared schema components for `$ref`
+ *   referencing
+ *
+ * This function serves as the underlying implementation for
+ * {@link llm.application}, and can be used when you need to:
+ *
+ * - Create your own custom LLM function calling schema format
+ * - Transform class methods into structured JSON schema format
+ * - Build API documentation or code generation tools
+ * - Develop alternative LLM integrations beyond the built-in providers
+ *
+ * For direct LLM function calling implementations, consider using
+ * {@link llm.application} instead, which provides provider-specific schemas for
+ * ChatGPT, Claude, Gemini, and other LLM providers.
  *
  * Also, you can specify the OpenAPI version by configuring the second generic
- * argument `Version`. For reference, the default version is `"3.1"`, and key
- * different of `"3.0"` and `"3.1"` is whether supporting the tuple type or
- * not.
+ * argument `Version`. For reference, the default version is `"3.1"`, and the
+ * key difference between `"3.0"` and `"3.1"` is whether supporting the tuple
+ * type or not.
  *
  * @author Jeongho Nam - https://github.com/samchon
- * @template Type Target type
+ * @template Class Target class or interface type containing the functions
  * @template Version Version of OpenAPI specification. Default is 3.1
- * @returns JSON schema unit
+ * @returns JSON function schema application
  */
-export function schema<
-  Type extends unknown,
+export function application<
+  Class extends object,
   Version extends "3.0" | "3.1" = "3.1",
->(): IJsonSchemaUnit<Version, Type>;
+>(): IJsonSchemaApplication<Version, Class>;
 
 /** @internal */
-export function schema(): never {
-  NoTransformConfigurationError("json.schema");
+export function application(): never {
+  NoTransformConfigurationError("json.application");
 }
 
 /* -----------------------------------------------------------

package/src/module.ts

@@ -19,7 +19,7 @@ export * as reflect from "./reflect";
 export * as tags from "./tags";
 
 export * from "./schemas/metadata/IJsDocTagInfo";
-export * from "./schemas/json/IJsonApplication";
+export * from "./schemas/json/IJsonSchemaApplication";
 export * from "./schemas/json/IJsonSchemaCollection";
 export * from "./schemas/json/IJsonSchemaUnit";
 export * from "./AssertionGuard";

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -1,6 +1,6 @@
 import { MetadataFactory } from "../../factories/MetadataFactory";
 
-import { __IJsonApplication } from "../../schemas/json/__IJsonApplication";
+import { IJsonSchemaApplication } from "../../schemas/json/IJsonSchemaApplication";
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataFunction } from "../../schemas/metadata/MetadataFunction";
@@ -62,21 +62,22 @@ export namespace JsonApplicationProgrammer {
     version: Version;
     metadata: Metadata;
     filter?: (prop: MetadataProperty) => boolean;
-  }): __IJsonApplication<Version> => {
+  }): IJsonSchemaApplication<Version> => {
     const object: MetadataObjectType = props.metadata.objects[0]!.type;
     const definitions: Metadata[] = [];
-    const setters: Array<(schema: __IJsonApplication.Schema<Version>) => void> =
-      [];
+    const setters: Array<
+      (schema: IJsonSchemaApplication.Schema<Version>) => void
+    > = [];
     const collect = (
       metadata: Metadata,
-      setter: (schema: __IJsonApplication.Schema<Version>) => void,
+      setter: (schema: IJsonSchemaApplication.Schema<Version>) => void,
     ): void => {
       definitions.push(metadata);
       setters.push(setter);
     };
 
-    const functions: __IJsonApplication.IFunction<
-      __IJsonApplication.Schema<Version>
+    const functions: IJsonSchemaApplication.IFunction<
+      IJsonSchemaApplication.Schema<Version>
     >[] = object.properties
       .filter(
         (p) =>
@@ -108,7 +109,7 @@ export namespace JsonApplicationProgrammer {
       metadatas: definitions,
     });
     schemas.forEach((s, i) =>
-      setters[i]?.(s as __IJsonApplication.Schema<Version>),
+      setters[i]?.(s as IJsonSchemaApplication.Schema<Version>),
     );
     return {
       version: props.version,
@@ -152,9 +153,11 @@ export namespace JsonApplicationProgrammer {
     jsDocTags: IJsDocTagInfo[];
     collect: (
       metadata: Metadata,
-      setter: (schema: __IJsonApplication.Schema<Version>) => void,
+      setter: (schema: IJsonSchemaApplication.Schema<Version>) => void,
     ) => void;
-  }): __IJsonApplication.IFunction<__IJsonApplication.Schema<Version>> => {
+  }): IJsonSchemaApplication.IFunction<
+    IJsonSchemaApplication.Schema<Version>
+  > => {
     const deprecated: boolean = props.jsDocTags.some(
       (tag) => tag.name === "deprecated",
     );
@@ -172,8 +175,8 @@ export namespace JsonApplicationProgrammer {
       name: props.name,
       async: props.function.async,
       parameters: props.function.parameters.map((param) => {
-        const appParam: __IJsonApplication.IParameter<
-          __IJsonApplication.Schema<Version>
+        const appParam: IJsonSchemaApplication.IParameter<
+          IJsonSchemaApplication.Schema<Version>
         > = {
           name: param.name,
           ...writeDescription({
@@ -201,8 +204,8 @@ export namespace JsonApplicationProgrammer {
       }),
       output: props.function.output.size()
         ? (() => {
-            const appOutput: __IJsonApplication.IOutput<
-              __IJsonApplication.Schema<Version>
+            const appOutput: IJsonSchemaApplication.IOutput<
+              IJsonSchemaApplication.Schema<Version>
             > = {
               schema: null!,
               required: props.function.output.isRequired(),

package/src/programmers/json/JsonAssertStringifyProgrammer.ts

@@ -27,7 +27,7 @@ export namespace JsonAssertStringifyProgrammer {
         options: {
           ...props.context.options,
           functional: false,
-          numeric: true,
+          finite: true,
         },
       },
       config: {

package/src/programmers/json/JsonIsStringifyProgrammer.ts

@@ -26,7 +26,7 @@ export namespace JsonIsStringifyProgrammer {
         options: {
           ...props.context.options,
           functional: false,
-          numeric: true,
+          finite: true,
         },
       },
       config: {

package/src/programmers/json/JsonValidateStringifyProgrammer.ts

@@ -28,7 +28,7 @@ export namespace JsonValidateStringifyProgrammer {
           options: {
             ...props.context.options,
             functional: false,
-            numeric: true,
+            finite: true,
           },
         },
         config: {

package/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -14,7 +14,7 @@ import ts from "typescript";
 import { MetadataFactory } from "../../factories/MetadataFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { __IJsonApplication } from "../../schemas/json/__IJsonApplication";
+import { IJsonSchemaApplication } from "../../schemas/json/IJsonSchemaApplication";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataFunction } from "../../schemas/metadata/MetadataFunction";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
@@ -191,7 +191,7 @@ export namespace LlmApplicationProgrammer {
       );
 
     const errorMessages: string[] = [];
-    const application: __IJsonApplication<"3.1"> =
+    const application: IJsonSchemaApplication<"3.1"> =
       JsonApplicationProgrammer.write({
         version: "3.1",
         metadata,
@@ -233,7 +233,7 @@ export namespace LlmApplicationProgrammer {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     components: OpenApi.IComponents;
-    function: __IJsonApplication.IFunction<OpenApi.IJsonSchema>;
+    function: IJsonSchemaApplication.IFunction<OpenApi.IJsonSchema>;
     parameter: MetadataParameter | null;
     errors: string[];
     className?: string;
@@ -309,7 +309,7 @@ export namespace LlmApplicationProgrammer {
   const writeParameters = <Model extends ILlmSchema.Model>(props: {
     model: Model;
     components: OpenApi.IComponents;
-    function: __IJsonApplication.IFunction<OpenApi.IJsonSchema>;
+    function: IJsonSchemaApplication.IFunction<OpenApi.IJsonSchema>;
     errors: string[];
     accessor: string;
   }): ILlmSchema.ModelParameters[Model] | null => {

package/src/programmers/protobuf/ProtobufAssertEncodeProgrammer.ts

@@ -28,7 +28,7 @@ export namespace ProtobufAssertEncodeProgrammer {
         options: {
           ...props.context.options,
           functional: false,
-          numeric: true,
+          finite: true,
         },
       },
       config: {

package/src/programmers/protobuf/ProtobufIsEncodeProgrammer.ts

@@ -27,7 +27,7 @@ export namespace ProtobufIsEncodeProgrammer {
         options: {
           ...props.context.options,
           functional: false,
-          numeric: true,
+          finite: true,
         },
       },
       config: {

package/src/programmers/protobuf/ProtobufValidateEncodeProgrammer.ts

@@ -27,7 +27,7 @@ export namespace ProtobufValidateEncodeProgrammer {
         options: {
           ...props.context.options,
           functional: false,
-          numeric: true,
+          finite: true,
         },
       },
       config: {

package/src/schemas/json/{__IJsonApplication.ts → IJsonSchemaApplication.ts}

@@ -1,17 +1,19 @@
 import { OpenApi, OpenApiV3 } from "@samchon/openapi";
 
-export interface __IJsonApplication<
+export interface IJsonSchemaApplication<
   Version extends "3.0" | "3.1" = "3.1",
   App extends any = object,
 > {
   version: Version;
-  components: __IJsonApplication.IComponents<
-    __IJsonApplication.Schema<Version>
+  components: IJsonSchemaApplication.IComponents<
+    IJsonSchemaApplication.Schema<Version>
   >;
-  functions: __IJsonApplication.IFunction<__IJsonApplication.Schema<Version>>[];
+  functions: IJsonSchemaApplication.IFunction<
+    IJsonSchemaApplication.Schema<Version>
+  >[];
   __application?: App | undefined;
 }
-export namespace __IJsonApplication {
+export namespace IJsonSchemaApplication {
   export type Schema<Version extends "3.0" | "3.1"> = Version extends "3.1"
     ? OpenApi.IJsonSchema
     : OpenApiV3.IJsonSchema;

package/src/transformers/CallExpressionTransformer.ts

@@ -50,6 +50,7 @@ import { HttpQueryTransformer } from "./features/http/HttpQueryTransformer";
 import { HttpValidateFormDataTransformer } from "./features/http/HttpValidateFormDataTransformer";
 import { HttpValidateHeadersTransformer } from "./features/http/HttpValidateHeadersTransformer";
 import { HttpValidateQueryTransformer } from "./features/http/HttpValidateQueryTransformer";
+import { JsonApplicationTransformer } from "./features/json/JsonApplicationTransformer";
 // import { JsonApplicationTransformer } from "./features/json/JsonApplicationTransformer";
 import { JsonAssertParseTransformer } from "./features/json/JsonAssertParseTransformer";
 import { JsonAssertStringifyTransformer } from "./features/json/JsonAssertStringifyTransformer";
@@ -410,8 +411,9 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
   },
   json: {
     // METADATA
-    schemas: () => JsonSchemasTransformer.transform,
     schema: () => JsonSchemaTransformer.transform,
+    schemas: () => JsonSchemasTransformer.transform,
+    application: () => JsonApplicationTransformer.transform,
 
     // PARSER
     isParse: () => JsonIsParseTransformer.transform,

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -1,105 +1,105 @@
-// import ts from "typescript";
+import ts from "typescript";
 
-// import { LiteralFactory } from "../../../factories/LiteralFactory";
-// import { MetadataCollection } from "../../../factories/MetadataCollection";
-// import { MetadataFactory } from "../../../factories/MetadataFactory";
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
 
-// import { IJsonApplication } from "../../../schemas/json/IJsonApplication";
-// import { Metadata } from "../../../schemas/metadata/Metadata";
+import { IJsonSchemaApplication } from "../../../schemas/json/IJsonSchemaApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
 
-// import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
+import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
 
-// import { ValidationPipe } from "../../../typings/ValidationPipe";
+import { ValidationPipe } from "../../../typings/ValidationPipe";
 
-// import { ITransformProps } from "../../ITransformProps";
-// import { TransformerError } from "../../TransformerError";
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
 
-// export namespace JsonApplicationTransformer {
-//   export const transform = (props: ITransformProps): ts.Expression => {
-//     // GET GENERIC ARGUMENT
-//     if (!props.expression.typeArguments?.length)
-//       throw new TransformerError({
-//         code: "typia.json.application",
-//         message: "no generic argument.",
-//       });
+export namespace JsonApplicationTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.json.application",
+        message: "no generic argument.",
+      });
 
-//     const top: ts.Node = props.expression.typeArguments[0]!;
-//     if (ts.isTypeNode(top) === false) return props.expression;
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
 
-//     const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
-//       checker: props.context.checker,
-//       name: "Version",
-//       is: (str) => str === "3.0" || str === "3.1",
-//       cast: (str) => str as "3.0" | "3.1",
-//       default: () => "3.1",
-//     })(props.expression.typeArguments[1]);
+    const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
+      checker: props.context.checker,
+      name: "Version",
+      is: (str) => str === "3.0" || str === "3.1",
+      cast: (str) => str as "3.0" | "3.1",
+      default: () => "3.1",
+    })(props.expression.typeArguments[1]);
 
-//     // GET TYPE
-//     const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
-//     const collection: MetadataCollection = new MetadataCollection({
-//       replace: MetadataCollection.replace,
-//     });
-//     const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-//       MetadataFactory.analyze({
-//         checker: props.context.checker,
-//         transformer: props.context.transformer,
-//         options: {
-//           escape: true,
-//           constant: true,
-//           absorb: false,
-//           functional: true,
-//           validate: JsonApplicationProgrammer.validate,
-//         },
-//         collection,
-//         type,
-//       });
-//     if (result.success === false)
-//       throw TransformerError.from({
-//         code: "typia.json.application",
-//         errors: result.errors,
-//       });
+    // GET TYPE
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+    const collection: MetadataCollection = new MetadataCollection({
+      replace: MetadataCollection.replace,
+    });
+    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+      MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: true,
+          constant: true,
+          absorb: false,
+          functional: true,
+          validate: JsonApplicationProgrammer.validate,
+        },
+        collection,
+        type,
+      });
+    if (result.success === false)
+      throw TransformerError.from({
+        code: "typia.json.application",
+        errors: result.errors,
+      });
 
-//     // GENERATE LLM APPLICATION
-//     const app: IJsonApplication<"3.0" | "3.1"> =
-//       JsonApplicationProgrammer.write({
-//         version,
-//         metadata: result.data,
-//       });
-//     const literal: ts.Expression = LiteralFactory.write(app);
-//     return literal;
-//   };
+    // GENERATE LLM APPLICATION
+    const app: IJsonSchemaApplication<"3.0" | "3.1"> =
+      JsonApplicationProgrammer.write({
+        version,
+        metadata: result.data,
+      });
+    const literal: ts.Expression = LiteralFactory.write(app);
+    return literal;
+  };
 
-//   const get_parameter =
-//     <Value>(props: {
-//       checker: ts.TypeChecker;
-//       name: string;
-//       is: (value: string) => boolean;
-//       cast: (value: string) => Value;
-//       default: () => Value;
-//     }) =>
-//     (node: ts.TypeNode | undefined): Value => {
-//       if (!node) return props.default();
+  const get_parameter =
+    <Value>(props: {
+      checker: ts.TypeChecker;
+      name: string;
+      is: (value: string) => boolean;
+      cast: (value: string) => Value;
+      default: () => Value;
+    }) =>
+    (node: ts.TypeNode | undefined): Value => {
+      if (!node) return props.default();
 
-//       // CHECK LITERAL TYPE
-//       const type: ts.Type = props.checker.getTypeFromTypeNode(node);
-//       if (
-//         !type.isLiteral() &&
-//         (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
-//       )
-//         throw new TransformerError({
-//           code: "typia.json.application",
-//           message: `generic argument "${props.name}" must be constant.`,
-//         });
+      // CHECK LITERAL TYPE
+      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
+      if (
+        !type.isLiteral() &&
+        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+      )
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `generic argument "${props.name}" must be constant.`,
+        });
 
-//       // GET VALUE AND VALIDATE IT
-//       const value = type.isLiteral()
-//         ? type.value
-//         : props.checker.typeToString(type);
-//       if (typeof value !== "string" || props.is(value) === false)
-//         throw new TransformerError({
-//           code: "typia.json.application",
-//           message: `invalid value on generic argument "${props.name}".`,
-//         });
-//       return props.cast(value);
-//     };
-// }
+      // GET VALUE AND VALIDATE IT
+      const value = type.isLiteral()
+        ? type.value
+        : props.checker.typeToString(type);
+      if (typeof value !== "string" || props.is(value) === false)
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
+}

package/lib/schemas/json/IJsonApplication.d.mts

@@ -1,16 +0,0 @@
-import { IJsonSchemaCollection } from "./IJsonSchemaCollection";
-/**
- * Collection of JSON schemas.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @deprecated Use {@link IJsonSchemaCollection} instead please. This interface
- *   type would be changed to {@link ILlmApplication} like structure in the
- *   future version (maybe next v8 major update).
- * @template Version Version of the OpenAPI specification.
- * @template Types Original TypeScript types used in the JSON schemas.
- */
-export type IJsonApplication = IJsonSchemaCollection;
-export declare namespace IJsonApplication {
-    type IV3_0 = IJsonSchemaCollection.IV3_0;
-    type IV3_1 = IJsonSchemaCollection.IV3_1;
-}