typia 7.7.0-dev.20250130 → 8.0.0-dev.20250221

package/src/llm.ts

@@ -24,7 +24,7 @@ import { ILlmApplicationOfValidate } from "./module";
  *
  * By the way, there can be some parameters (or their nested properties) which must be
  * composed by human, not by LLM. File uploading feature or some sensitive information
- * like secrety key (password) are the examples. In that case, you can separate the
+ * like security keys (password) are the examples. In that case, you can separate the
  * function parameters to both LLM and human sides by configuring the
  * {@link ILlmApplicationOfValidate.IOptions.separate} property. The separated parameters
  * are assigned to the {@link ILlmFunctionOfValidate.separated} property.
@@ -85,7 +85,7 @@ export function applicationOfValidate(
  *
  * By the way, there can be some parameters (or their nested properties) which must be
  * composed by human, not by LLM. File uploading feature or some sensitive information
- * like secrety key (password) are the examples. In that case, you can separate the
+ * like security keys (password) are the examples. In that case, you can separate the
  * function parameters to both LLM and human sides by configuring the
  * {@link ILlmApplicationOfValidate.IOptions.separate} property. The separated parameters
  * are assigned to the {@link ILlmFunctionOfValidate.separated} property.
@@ -155,7 +155,7 @@ export function applicationOfValidate(): never {
  *
  * By the way, there can be some parameters (or their nested properties) which must be
  * composed by human, not by LLM. File uploading feature or some sensitive information
- * like secrety key (password) are the examples. In that case, you can separate the
+ * like security keys (password) are the examples. In that case, you can separate the
  * function parameters to both LLM and human sides by configuring the
  * {@link ILlmApplication.IOptions.separate} property. The separated parameters are
  * assigned to the {@link ILlmFunction.separated} property.
@@ -210,7 +210,7 @@ export function application(
  *
  * By the way, there can be some parameters (or their nested properties) which must be
  * composed by human, not by LLM. File uploading feature or some sensitive information
- * like secrety key (password) are the examples. In that case, you can separate the
+ * like security keys (password) are the examples. In that case, you can separate the
  * function parameters to both LLM and human sides by configuring the
  * {@link ILlmApplication.IOptions.separate} property. The separated parameters are
  * assigned to the {@link ILlmFunction.separated} property.
@@ -385,8 +385,8 @@ export function parameters(): never {
  *
  * > **What LLM function calling is?
  * >
- * > LLM (Large Language Model) selects propert function and fill the arguments,
- * > but actuall function call execution is not by LLM, but by you.
+ * > LLM (Large Language Model) selects property function and fill the arguments,
+ * > but actual function call execution is not by LLM, but by you.
  * >
  * > In nowadays, most LLM (Large Language Model) like OpenAI are supporting
  * > "function calling" feature. The "function calling" means that LLM automatically selects
@@ -432,8 +432,8 @@ export function schema(): never;
  *
  * > **What LLM function calling is?
  * >
- * > LLM (Large Language Model) selects propert function and fill the arguments,
- * > but actuall function call execution is not by LLM, but by you.
+ * > LLM (Large Language Model) selects property function and fill the arguments,
+ * > but actual function call execution is not by LLM, but by you.
  * >
  * > In nowadays, most LLM (Large Language Model) like OpenAI are supporting
  * > "function calling" feature. The "function calling" means that LLM automatically selects

package/src/misc.ts

@@ -1,5 +1,5 @@
 /* ===========================================================
-    MISCELLAENOUS
+    MISCELLANEOUS
       - LITERALS
       - CLONE
       - PRUNE
@@ -365,7 +365,7 @@ export function isPrune(): never {
  *
  * In such reason, when `input` value is not matched with the type `T`, it returns
  * {@link IValidation.IFailure} value with detailed error reasons. Otherwise, there's
- * no problem on the `input` value, it returns {@link IValidation.ISucess} value after
+ * no problem on the `input` value, it returns {@link IValidation.ISuccess} value after
  * removing every superfluous properties, including nested objects.
  *
  * @template T Type of the input value
@@ -385,7 +385,7 @@ export function validatePrune<T>(input: T): IValidation<T>;
  *
  * In such reason, when `input` value is not matched with the type `T`, it returns
  * {@link IValidation.IFailure} value with detailed error reasons. Otherwise, there's
- * no problem on the `input` value, it returns {@link IValidation.ISucess} value after
+ * no problem on the `input` value, it returns {@link IValidation.ISuccess} value after
  * removing every superfluous properties, including nested objects.
  *
  * @template T Type of the input value
@@ -418,7 +418,7 @@ export function validatePrune<T>(): IValidation<T> {
 export function createClone(): never;
 
 /**
- * Creates a resuable {@link clone} function.
+ * Creates a reusable {@link clone} function.
  *
  * @template T Type of the input value
  * @returns A reusable `clone` function
@@ -449,7 +449,7 @@ export function createAssertClone(
 ): never;
 
 /**
- * Creates a resuable {@link assertClone} function.
+ * Creates a reusable {@link assertClone} function.
  *
  * @template T Type of the input value
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
@@ -480,7 +480,7 @@ export function createAssertClone(): never {
 export function createIsClone(): never;
 
 /**
- * Creates a resuable {@link isClone} function.
+ * Creates a reusable {@link isClone} function.
  *
  * @template T Type of the input value
  * @returns A reusable `clone` function
@@ -508,7 +508,7 @@ export function createIsClone(): never {
 export function createValidateClone(): never;
 
 /**
- * Creates a resuable {@link validateClone} function.
+ * Creates a reusable {@link validateClone} function.
  *
  * @template T Type of the input value
  * @returns A reusable `clone` function
@@ -538,7 +538,7 @@ export function createValidateClone(): never {
 export function createPrune(): never;
 
 /**
- * Creates a resuable {@link prune} function.
+ * Creates a reusable {@link prune} function.
  *
  * @template T Type of the input value
  * @returns A reusable `prune` function
@@ -569,7 +569,7 @@ export function createAssertPrune(
 ): never;
 
 /**
- * Creates a resuable {@link assertPrune} function.
+ * Creates a reusable {@link assertPrune} function.
  *
  * @template T Type of the input value
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
@@ -600,7 +600,7 @@ export function createAssertPrune<T extends object>(): (input: T) => T {
 export function createIsPrune(): never;
 
 /**
- * Creates a resuable {@link isPrune} function.
+ * Creates a reusable {@link isPrune} function.
  *
  * @template T Type of the input value
  * @returns A reusable `isPrune` function
@@ -628,7 +628,7 @@ export function createIsPrune<T extends object>(): (input: T) => input is T {
 export function createValidatePrune(): never;
 
 /**
- * Creates a resuable {@link validatePrune} function.
+ * Creates a reusable {@link validatePrune} function.
  *
  * @template T Type of the input value
  * @returns A reusable `validatePrune` function

package/src/module.ts

@@ -908,7 +908,7 @@ export function createValidateEquals(): (input: unknown) => IValidation {
 export function createRandom(generator?: Partial<IRandomGenerator>): never;
 
 /**
- * Creates a resuable {@link random} function.
+ * Creates a reusable {@link random} function.
  *
  * @template T Type of the input value
  * @param generator Random data generator

package/src/programmers/FeatureProgrammer.ts

@@ -150,7 +150,7 @@ export namespace FeatureProgrammer {
        * Transformer of non-undefined type checking by discrimination.
        *
        * When specifying an union type of objects, `typia` tries to find
-       * descrimination way just by checking only one property type.
+       * discrimination way just by checking only one property type.
        * If succeeded to find the discrimination way, `typia` will check the target
        * property type and in the checking, non-undefined type checking would be
        * done.
@@ -164,10 +164,10 @@ export namespace FeatureProgrammer {
       required?: undefined | ((exp: ts.Expression) => ts.Expression);
 
       /**
-       * Conditon wrapper when unable to specify any object type.
+       * Condition wrapper when unable to specify any object type.
        *
        * When failed to specify an object type through discrimination, full
-       * iteration type checking would be happend. In such circumstance, you
+       * iteration type checking would be happened. In such circumstance, you
        * can wrap the condition with additional function.
        *
        * @param props Properties of condition

package/src/programmers/TypiaProgrammer.ts

@@ -104,7 +104,7 @@ export namespace TypiaProgrammer {
               ? "suggestion"
               : diag.category === ts.DiagnosticCategory.Message
                 ? "message"
-                : "unkown";
+                : "unknown";
       const [line, pos] = diag.file
         ? (() => {
             const lines: string[] = diag

package/src/programmers/helpers/UnionExplorer.ts

@@ -79,7 +79,7 @@ export namespace UnionExplorer {
           props.input,
           key,
         );
-        const pred: ts.Expression = spec.neighbour
+        const pred: ts.Expression = spec.neighbor
           ? props.config.objector.checker({
               input: accessor,
               metadata: spec.property.value,

package/src/programmers/helpers/UnionPredicator.ts

@@ -10,7 +10,7 @@ export namespace UnionPredicator {
     index: number;
     object: MetadataObjectType;
     property: MetadataProperty;
-    neighbour: boolean;
+    neighbor: boolean;
   }
 
   export const object = (
@@ -55,7 +55,7 @@ export namespace UnionPredicator {
         if (unique === true)
           children.push({
             property: prop,
-            neighbour: neighbors.length !== 0,
+            neighbor: neighbors.length !== 0,
           });
       });
       if (children.length === 0) return;
@@ -75,5 +75,5 @@ export namespace UnionPredicator {
 
 interface ISpecializedProperty {
   property: MetadataProperty;
-  neighbour: boolean;
+  neighbor: boolean;
 }

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -24,7 +24,7 @@ export namespace JsonApplicationProgrammer {
       metadata.nullable === false;
     if (valid === false)
       output.push(
-        "JSON application's generic arugment must be a class/interface type.",
+        "JSON application's generic argument must be a class/interface type.",
       );
 
     const object: MetadataObjectType | undefined = metadata.objects[0]?.type;

package/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -49,7 +49,7 @@ export namespace LlmApplicationProgrammer {
         metadata.nullable === false;
       if (validity === false)
         output.push(
-          "LLM application's generic arugment must be a class/interface type.",
+          "LLM application's generic argument must be a class/interface type.",
         );
 
       const object: MetadataObjectType | undefined = metadata.objects[0]?.type;
@@ -116,7 +116,7 @@ export namespace LlmApplicationProgrammer {
       output.push(`${prefix} name must not start with a number.`);
     if (/^[a-zA-Z0-9_-]+$/.test(name) === false)
       output.push(
-        `${prefix} name must be alphanumeric with underscore or hypen.`,
+        `${prefix} name must be alphanumeric with underscore or hyphen.`,
       );
     if (name.length > 64)
       output.push(`${prefix} name must not exceed 64 characters.`);

package/src/programmers/llm/LlmModelPredicator.ts

@@ -28,9 +28,9 @@ export namespace LlmModelPredicator {
         checker: props.context.checker,
         transformer: props.context.transformer,
         options: {
+          absorb: true,
           escape: false,
           constant: true,
-          absorb: false,
           functional: false,
         },
         collection,

package/src/programmers/llm/LlmParametersProgrammer.ts

@@ -71,7 +71,7 @@ export namespace LlmParametersProgrammer {
       const output: string[] = [];
       if (explore.top === true) {
         if (metadata.objects.length === 0)
-          output.push("LLM parameters must be an objec type.");
+          output.push("LLM parameters must be an object type.");
         else if (metadata.objects.length !== 1 || metadata.size() > 1)
           output.push("LLM parameters must be a single object type.");
         else {

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -828,7 +828,7 @@ export namespace ProtobufEncodeProgrammer {
           props.input,
           key,
         );
-        const pred: ts.Expression = spec.neighbour
+        const pred: ts.Expression = spec.neighbor
           ? IsProgrammer.decode({
               context: props.context,
               functor: props.functor,

package/src/schemas/llm/ILlmApplicationOfValidate.ts

@@ -23,7 +23,7 @@ import { ILlmFunctionOfValidate } from "./ILlmFunctionOfValidate";
  *
  * By the way, there can be some parameters (or their nested properties) which must be
  * composed by Human, not by LLM. File uploading feature or some sensitive information
- * like secrety key (password) are the examples. In that case, you can separate the
+ * like secret keys (password) are the examples. In that case, you can separate the
  * function parameters to both LLM and human sides by configuring the
  * {@link ILlmApplication.IOptions.separate} property. The separated parameters are
  * assigned to the {@link ILlmFunction.separated} property.
@@ -31,7 +31,7 @@ import { ILlmFunctionOfValidate } from "./ILlmFunctionOfValidate";
  * For reference, when both LLM and Human filled parameter values to call, you can
  * merge them by calling the {@link HttpLlm.mergeParameters} function. In other words,
  * if you've configured the {@link ILlmApplication.IOptions.separate} property, you
- * have to merge the separated parameters before the funtion call execution.
+ * have to merge the separated parameters before the function call execution.
  *
  * @reference https://platform.openai.com/docs/guides/function-calling
  * @author Jeongho Nam - https://github.com/samchon

package/src/tags/Examples.ts

@@ -1,16 +1,16 @@
 import { TagBase } from "./TagBase";
 
 export type Examples<
-  Dict extends Record<
+  Value extends Record<
     string,
     boolean | bigint | number | string | object | Array<unknown> | null
   >,
 > = TagBase<{
   target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
   kind: "examples";
-  value: Dict;
+  value: Value;
   exclusive: true;
   schema: {
-    examples: Dict;
+    examples: Value;
   };
 }>;

package/src/transformers/ImportTransformer.ts

@@ -75,7 +75,7 @@ export namespace ImportTransformer {
 }
 
 const get_directory_path = (file: string): string => {
-  const splitted: string[] = path.resolve(file).split(path.sep);
-  splitted.pop();
-  return path.resolve(splitted.join(path.sep));
+  const split: string[] = path.resolve(file).split(path.sep);
+  split.pop();
+  return path.resolve(split.join(path.sep));
 };

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

@@ -56,42 +56,44 @@ export namespace JsonSchemasTransformer {
     // GENERATORS
     //----
     // METADATA
-    const collection: MetadataCollection = new MetadataCollection({
-      replace: MetadataCollection.replace,
-    });
-    const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
-      types.map((type) =>
-        MetadataFactory.analyze({
-          checker: props.context.checker,
-          transformer: props.context.transformer,
-          options: {
-            escape: true,
-            constant: true,
-            absorb: false,
-            validate: JsonSchemasProgrammer.validate,
-          },
-          collection,
-          type,
-        }),
-      );
-
-    // REPORT BUG IF REQUIRED
-    const metadatas: Metadata[] = [];
-    const errors: MetadataFactory.IError[] = [];
-    for (const r of results) {
-      if (r.success === false) errors.push(...r.errors);
-      else metadatas.push(r.data);
-    }
-    if (errors.length)
-      throw TransformerError.from({
-        code: "typia.json.application",
-        errors,
-      });
+    const analyze = (validate: boolean): Metadata[] => {
+      const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
+        types.map((type) =>
+          MetadataFactory.analyze({
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            options: {
+              absorb: validate,
+              constant: true,
+              escape: true,
+              validate:
+                validate === true ? JsonSchemasProgrammer.validate : undefined,
+            },
+            collection: new MetadataCollection({
+              replace: MetadataCollection.replace,
+            }),
+            type,
+          }),
+        );
+      const metadatas: Metadata[] = [];
+      const errors: MetadataFactory.IError[] = [];
+      for (const r of results) {
+        if (r.success === false) errors.push(...r.errors);
+        else metadatas.push(r.data);
+      }
+      if (errors.length)
+        throw TransformerError.from({
+          code: "typia.json.application",
+          errors,
+        });
+      return metadatas;
+    };
+    analyze(true);
 
     // APPLICATION
     const app: IJsonSchemaCollection<any> = JsonSchemasProgrammer.write({
       version,
-      metadatas,
+      metadatas: analyze(false),
     });
     return ts.factory.createAsExpression(
       LiteralFactory.write(app),

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

@@ -7,7 +7,7 @@ export namespace JsonValidateParseTransformer {
   export const transform = (props: ITransformProps) =>
     GenericTransformer.scalar({
       ...props,
-      method: "json.validatParse",
+      method: "json.validateParse",
       write: JsonValidateParseProgrammer.write,
     });
 }

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

@@ -7,7 +7,7 @@ export namespace JsonValidateStringifyTransformer {
   export const transform = (props: ITransformProps) =>
     GenericTransformer.scalar({
       ...props,
-      method: "json.validatStringify",
+      method: "json.validateStringify",
       write: JsonValidateStringifyProgrammer.write,
     });
 }

package/src/transformers/features/llm/LlmApplicationOfValidateTransformer.ts

@@ -43,31 +43,39 @@ export namespace LlmApplicationOfValidateTransformer {
     }) as Partial<ILlmSchema.IConfig>;
 
     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: LlmApplicationOfValidateProgrammer.validate({
-            model,
-            config,
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): Metadata => {
+      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            functional: true,
+            validate:
+              validate === true
+                ? LlmApplicationOfValidateProgrammer.validate({
+                    model,
+                    config,
+                  })
+                : undefined,
+          },
+          collection: new MetadataCollection({
+            replace: MetadataCollection.replace,
           }),
-        },
-        collection,
-        type,
-      });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: "typia.llm.application",
-        errors: result.errors,
-      });
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.applicationOfValidate",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
 
     // GENERATE LLM APPLICATION
     const schema: ILlmApplication<ILlmSchema.Model> =
@@ -75,7 +83,7 @@ export namespace LlmApplicationOfValidateTransformer {
         model,
         context: props.context,
         modulo: props.modulo,
-        metadata: result.data,
+        metadata: analyze(false),
         config,
         name: top.getFullText().trim(),
       });

package/src/transformers/features/llm/LlmApplicationTransformer.ts

@@ -43,37 +43,44 @@ export namespace LlmApplicationTransformer {
     }) as Partial<ILlmSchema.IConfig>;
 
     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: LlmApplicationProgrammer.validate({
-            model,
-            config,
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): Metadata => {
+      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            functional: true,
+            validate:
+              validate === true
+                ? LlmApplicationProgrammer.validate({
+                    model,
+                    config,
+                  })
+                : undefined,
+          },
+          collection: new MetadataCollection({
+            replace: MetadataCollection.replace,
           }),
-        },
-        collection,
-        type,
-      });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: "typia.llm.applicationOfValidate",
-        errors: result.errors,
-      });
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.application",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
 
     // GENERATE LLM APPLICATION
     const schema: ILlmApplication<ILlmSchema.Model> =
       LlmApplicationProgrammer.write({
         model,
-        metadata: result.data,
+        metadata: analyze(false),
         config,
       });
     const literal: ts.Expression = ts.factory.createAsExpression(

package/src/transformers/features/llm/LlmParametersTransformer.ts

@@ -44,35 +44,43 @@ export namespace LlmParametersTransformer {
     }) as Partial<ILlmSchema.IConfig>;
 
     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,
-          validate: LlmParametersProgrammer.validate({
-            model,
-            config,
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): Metadata => {
+      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            validate:
+              validate === true
+                ? LlmParametersProgrammer.validate({
+                    model,
+                    config,
+                  })
+                : undefined,
+          },
+          collection: new MetadataCollection({
+            replace: MetadataCollection.replace,
           }),
-        },
-        collection,
-        type,
-      });
-    if (result.success === false)
-      throw TransformerError.from({
-        code: "typia.llm.parameters",
-        errors: result.errors,
-      });
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.parameters",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
 
     // GENERATE LLM SCHEMA
     const out: ILlmFunction<any>["parameters"] = LlmParametersProgrammer.write({
       model,
-      metadata: result.data,
+      metadata: analyze(false),
       config,
     });
     return ts.factory.createAsExpression(