typia 9.7.1 → 9.7.2

package/lib/AssertionGuard.d.mts

@@ -1,39 +1,41 @@
 /**
  * Type definition for assertion guard functions in `typia`.
  *
- * An assertion guard is a function that asserts an input value's type at runtime
- * and performs a TypeScript type assertion if validation passes. Unlike regular
- * assertion functions that return the validated value, assertion guards return
- * nothing but automatically cast the input parameter to the expected type `T`.
+ * An assertion guard is a function that asserts an input value's type at
+ * runtime and performs a TypeScript type assertion if validation passes. Unlike
+ * regular assertion functions that return the validated value, assertion guards
+ * return nothing but automatically cast the input parameter to the expected
+ * type `T`.
  *
- * This type is used by `typia.createAssertGuard<T>()` and `typia.createAssertGuardEquals<T>()`
- * to generate reusable assertion guard functions.
- *
- * @template T - The expected type to validate and assert against
- * @param input - The value to validate (type unknown)
- * @throws {TypeGuardError} When the input value doesn't match the expected type T
- * @returns void - Returns nothing, but asserts that input is type T
+ * This type is used by `typia.createAssertGuard<T>()` and
+ * `typia.createAssertGuardEquals<T>()` to generate reusable assertion guard
+ * functions.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @example
- * ```typescript
- * interface IMember {
- *   name: string;
- *   age: number;
- * }
+ *   ```typescript
+ *   interface IMember {
+ *     name: string;
+ *     age: number;
+ *   }
  *
- * // Create reusable assertion guard
- * const assertMember: AssertionGuard<IMember> = typia.createAssertGuard<IMember>();
+ *   // Create reusable assertion guard
+ *   const assertMember: AssertionGuard<IMember> = typia.createAssertGuard<IMember>();
  *
- * // Usage - input will be automatically cast to IMember if validation passes
- * const unknownData: unknown = { name: "John", age: 25 };
+ *   // Usage - input will be automatically cast to IMember if validation passes
+ *   const unknownData: unknown = { name: "John", age: 25 };
  *
- * assertMember(unknownData);
- * // After this line, unknownData is automatically treated as IMember type
- * console.log(unknownData.name); // TypeScript knows this is safe
- * ```
+ *   assertMember(unknownData);
+ *   // After this line, unknownData is automatically treated as IMember type
+ *   console.log(unknownData.name); // TypeScript knows this is safe
+ *   ```;
  *
+ * @template T - The expected type to validate and assert against
+ * @param input - The value to validate (type unknown)
+ * @returns Void - Returns nothing, but asserts that input is type T
+ * @throws {TypeGuardError} When the input value doesn't match the expected type
+ *   T
  * @see {@link https://github.com/samchon/typia#assertguard-functions} Typia assertion guards documentation
  * @see {@link TypeGuardError} Error thrown when assertion fails
- * @author Jeongho Nam - https://github.com/samchon
  */
 export type AssertionGuard<T> = (input: unknown) => asserts input is T;

package/lib/AssertionGuard.d.ts

@@ -1,39 +1,41 @@
 /**
  * Type definition for assertion guard functions in `typia`.
  *
- * An assertion guard is a function that asserts an input value's type at runtime
- * and performs a TypeScript type assertion if validation passes. Unlike regular
- * assertion functions that return the validated value, assertion guards return
- * nothing but automatically cast the input parameter to the expected type `T`.
+ * An assertion guard is a function that asserts an input value's type at
+ * runtime and performs a TypeScript type assertion if validation passes. Unlike
+ * regular assertion functions that return the validated value, assertion guards
+ * return nothing but automatically cast the input parameter to the expected
+ * type `T`.
  *
- * This type is used by `typia.createAssertGuard<T>()` and `typia.createAssertGuardEquals<T>()`
- * to generate reusable assertion guard functions.
- *
- * @template T - The expected type to validate and assert against
- * @param input - The value to validate (type unknown)
- * @throws {TypeGuardError} When the input value doesn't match the expected type T
- * @returns void - Returns nothing, but asserts that input is type T
+ * This type is used by `typia.createAssertGuard<T>()` and
+ * `typia.createAssertGuardEquals<T>()` to generate reusable assertion guard
+ * functions.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @example
- * ```typescript
- * interface IMember {
- *   name: string;
- *   age: number;
- * }
+ *   ```typescript
+ *   interface IMember {
+ *     name: string;
+ *     age: number;
+ *   }
  *
- * // Create reusable assertion guard
- * const assertMember: AssertionGuard<IMember> = typia.createAssertGuard<IMember>();
+ *   // Create reusable assertion guard
+ *   const assertMember: AssertionGuard<IMember> = typia.createAssertGuard<IMember>();
  *
- * // Usage - input will be automatically cast to IMember if validation passes
- * const unknownData: unknown = { name: "John", age: 25 };
+ *   // Usage - input will be automatically cast to IMember if validation passes
+ *   const unknownData: unknown = { name: "John", age: 25 };
  *
- * assertMember(unknownData);
- * // After this line, unknownData is automatically treated as IMember type
- * console.log(unknownData.name); // TypeScript knows this is safe
- * ```
+ *   assertMember(unknownData);
+ *   // After this line, unknownData is automatically treated as IMember type
+ *   console.log(unknownData.name); // TypeScript knows this is safe
+ *   ```;
  *
+ * @template T - The expected type to validate and assert against
+ * @param input - The value to validate (type unknown)
+ * @returns Void - Returns nothing, but asserts that input is type T
+ * @throws {TypeGuardError} When the input value doesn't match the expected type
+ *   T
  * @see {@link https://github.com/samchon/typia#assertguard-functions} Typia assertion guards documentation
  * @see {@link TypeGuardError} Error thrown when assertion fails
- * @author Jeongho Nam - https://github.com/samchon
  */
 export type AssertionGuard<T> = (input: unknown) => asserts input is T;

package/lib/CamelCase.d.mts

@@ -9,8 +9,8 @@ import { ValueOf } from "./typings/ValueOf";
  *
  * It also erases every method property like {@link Resolved} type.
  *
- * @template T Target type to be camelized
  * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to be camelized
  */
 export type CamelCase<T> = Equal<T, CamelizeMain<T>> extends true ? T : CamelizeMain<T>;
 type CamelizeMain<T> = T extends [never] ? never : T extends {

package/lib/CamelCase.d.ts

@@ -9,8 +9,8 @@ import { ValueOf } from "./typings/ValueOf";
  *
  * It also erases every method property like {@link Resolved} type.
  *
- * @template T Target type to be camelized
  * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to be camelized
  */
 export type CamelCase<T> = Equal<T, CamelizeMain<T>> extends true ? T : CamelizeMain<T>;
 type CamelizeMain<T> = T extends [never] ? never : T extends {

package/lib/IRandomGenerator.d.mts

@@ -2,28 +2,28 @@ import { OpenApi } from "@samchon/openapi";
 /**
  * Interface for generating random values for various data types.
  *
- * `IRandomGenerator` defines the contract for generating random values
- * that can be used by typia for creating mock data, testing scenarios,
- * and random value generation based on JSON schema constraints.
+ * `IRandomGenerator` defines the contract for generating random values that can
+ * be used by typia for creating mock data, testing scenarios, and random value
+ * generation based on JSON schema constraints.
  *
  * This interface supports generating random values for:
+ *
  * - Basic types (boolean, number, integer, bigint, string, array)
  * - String format patterns (email, URL, UUID, etc.)
  * - Date and time formats
  * - Various address and identifier formats
  *
- * @example
- * ```typescript
- * const generator: IRandomGenerator = {
- *   boolean: () => Math.random() > 0.5,
- *   number: (schema) => Math.random() * (schema.maximum ?? 100),
- *   string: (schema) => "example-string",
- *   email: () => "test@example.com",
- *   // ... implement other methods
- * };
- * ```
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   const generator: IRandomGenerator = {
+ *     boolean: () => Math.random() > 0.5,
+ *     number: (schema) => Math.random() * (schema.maximum ?? 100),
+ *     string: (schema) => "example-string",
+ *     email: () => "test@example.com",
+ *     // ... implement other methods
+ *   };
+ *   ```;
  */
 export interface IRandomGenerator {
     /**
@@ -56,12 +56,14 @@ export interface IRandomGenerator {
     /**
      * Generates a random string based on JSON schema constraints.
      *
-     * @param schema JSON schema with string constraints (minLength, maxLength, pattern, etc.)
+     * @param schema JSON schema with string constraints (minLength, maxLength,
+     *   pattern, etc.)
      * @returns Random string matching the specified constraints
      */
     string(schema: OpenApi.IJsonSchema.IString): string;
     /**
-     * Generates a random array with elements created by the provided generator function.
+     * Generates a random array with elements created by the provided generator
+     * function.
      *
      * @param schema Array schema with element generator function
      * @returns Random array with generated elements
@@ -221,37 +223,37 @@ export declare namespace IRandomGenerator {
     /**
      * Map of custom generators for different data types.
      *
-     * This interface allows customization of random generation for specific
-     * types when they have certain schema properties or constraints.
+     * This interface allows customization of random generation for specific types
+     * when they have certain schema properties or constraints.
      *
      * @example
-     * ```typescript
-     * const generator: Partial<IRandomGenerator> = {
-     *   string: (schema) => {
-     *     if ((schema as any)["x-typia-monetary"] === "dollar") {
-     *       return "$" + Math.floor(Math.random() * 1000);
-     *     }
-     *     return "default-string";
-     *   },
-     *   number: (schema) => {
-     *     if ((schema as any)["x-typia-powerOf"] !== undefined) {
-     *       const powerOf = (schema as any)["x-typia-powerOf"];
-     *       return Math.pow(powerOf, Math.random() * 10 + 1);
+     *   ```typescript
+     *   const generator: Partial<IRandomGenerator> = {
+     *     string: (schema) => {
+     *       if ((schema as any)["x-typia-monetary"] === "dollar") {
+     *         return "$" + Math.floor(Math.random() * 1000);
+     *       }
+     *       return "default-string";
+     *     },
+     *     number: (schema) => {
+     *       if ((schema as any)["x-typia-powerOf"] !== undefined) {
+     *         const powerOf = (schema as any)["x-typia-powerOf"];
+     *         return Math.pow(powerOf, Math.random() * 10 + 1);
+     *       }
+     *       return Math.random() * 100;
      *     }
-     *     return Math.random() * 100;
-     *   }
-     * };
-     * ```
+     *   };
+     *   ```;
      */
     interface CustomMap {
         /**
-         * Custom string generator that can handle special string formats
-         * based on schema properties.
+         * Custom string generator that can handle special string formats based on
+         * schema properties.
          */
         string?: (schema: OpenApi.IJsonSchema.IString & Record<string, any>) => string;
         /**
-         * Custom number generator that can handle special number constraints
-         * based on schema properties.
+         * Custom number generator that can handle special number constraints based
+         * on schema properties.
          */
         number?: (schema: OpenApi.IJsonSchema.INumber & Record<string, any>) => number;
         /**
@@ -260,8 +262,8 @@ export declare namespace IRandomGenerator {
          */
         integer?: (schema: OpenApi.IJsonSchema.IInteger & Record<string, any>) => number;
         /**
-         * Custom bigint generator that can handle special bigint constraints
-         * based on schema properties.
+         * Custom bigint generator that can handle special bigint constraints based
+         * on schema properties.
          */
         bigint?: (schema: OpenApi.IJsonSchema.IInteger & Record<string, any>) => bigint;
         /**
@@ -270,8 +272,8 @@ export declare namespace IRandomGenerator {
          */
         boolean?: (schema: Record<string, any>) => boolean | undefined;
         /**
-         * Custom array generator that can handle special array constraints
-         * based on schema properties.
+         * Custom array generator that can handle special array constraints based on
+         * schema properties.
          */
         array?: <T>(schema: Omit<OpenApi.IJsonSchema.IArray, "items"> & {
             element: (index: number, count: number) => T;

package/lib/IRandomGenerator.d.ts

@@ -2,28 +2,28 @@ import { OpenApi } from "@samchon/openapi";
 /**
  * Interface for generating random values for various data types.
  *
- * `IRandomGenerator` defines the contract for generating random values
- * that can be used by typia for creating mock data, testing scenarios,
- * and random value generation based on JSON schema constraints.
+ * `IRandomGenerator` defines the contract for generating random values that can
+ * be used by typia for creating mock data, testing scenarios, and random value
+ * generation based on JSON schema constraints.
  *
  * This interface supports generating random values for:
+ *
  * - Basic types (boolean, number, integer, bigint, string, array)
  * - String format patterns (email, URL, UUID, etc.)
  * - Date and time formats
  * - Various address and identifier formats
  *
- * @example
- * ```typescript
- * const generator: IRandomGenerator = {
- *   boolean: () => Math.random() > 0.5,
- *   number: (schema) => Math.random() * (schema.maximum ?? 100),
- *   string: (schema) => "example-string",
- *   email: () => "test@example.com",
- *   // ... implement other methods
- * };
- * ```
- *
  * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   const generator: IRandomGenerator = {
+ *     boolean: () => Math.random() > 0.5,
+ *     number: (schema) => Math.random() * (schema.maximum ?? 100),
+ *     string: (schema) => "example-string",
+ *     email: () => "test@example.com",
+ *     // ... implement other methods
+ *   };
+ *   ```;
  */
 export interface IRandomGenerator {
     /**
@@ -56,12 +56,14 @@ export interface IRandomGenerator {
     /**
      * Generates a random string based on JSON schema constraints.
      *
-     * @param schema JSON schema with string constraints (minLength, maxLength, pattern, etc.)
+     * @param schema JSON schema with string constraints (minLength, maxLength,
+     *   pattern, etc.)
      * @returns Random string matching the specified constraints
      */
     string(schema: OpenApi.IJsonSchema.IString): string;
     /**
-     * Generates a random array with elements created by the provided generator function.
+     * Generates a random array with elements created by the provided generator
+     * function.
      *
      * @param schema Array schema with element generator function
      * @returns Random array with generated elements
@@ -221,37 +223,37 @@ export declare namespace IRandomGenerator {
     /**
      * Map of custom generators for different data types.
      *
-     * This interface allows customization of random generation for specific
-     * types when they have certain schema properties or constraints.
+     * This interface allows customization of random generation for specific types
+     * when they have certain schema properties or constraints.
      *
      * @example
-     * ```typescript
-     * const generator: Partial<IRandomGenerator> = {
-     *   string: (schema) => {
-     *     if ((schema as any)["x-typia-monetary"] === "dollar") {
-     *       return "$" + Math.floor(Math.random() * 1000);
-     *     }
-     *     return "default-string";
-     *   },
-     *   number: (schema) => {
-     *     if ((schema as any)["x-typia-powerOf"] !== undefined) {
-     *       const powerOf = (schema as any)["x-typia-powerOf"];
-     *       return Math.pow(powerOf, Math.random() * 10 + 1);
+     *   ```typescript
+     *   const generator: Partial<IRandomGenerator> = {
+     *     string: (schema) => {
+     *       if ((schema as any)["x-typia-monetary"] === "dollar") {
+     *         return "$" + Math.floor(Math.random() * 1000);
+     *       }
+     *       return "default-string";
+     *     },
+     *     number: (schema) => {
+     *       if ((schema as any)["x-typia-powerOf"] !== undefined) {
+     *         const powerOf = (schema as any)["x-typia-powerOf"];
+     *         return Math.pow(powerOf, Math.random() * 10 + 1);
+     *       }
+     *       return Math.random() * 100;
      *     }
-     *     return Math.random() * 100;
-     *   }
-     * };
-     * ```
+     *   };
+     *   ```;
      */
     interface CustomMap {
         /**
-         * Custom string generator that can handle special string formats
-         * based on schema properties.
+         * Custom string generator that can handle special string formats based on
+         * schema properties.
          */
         string?: (schema: OpenApi.IJsonSchema.IString & Record<string, any>) => string;
         /**
-         * Custom number generator that can handle special number constraints
-         * based on schema properties.
+         * Custom number generator that can handle special number constraints based
+         * on schema properties.
          */
         number?: (schema: OpenApi.IJsonSchema.INumber & Record<string, any>) => number;
         /**
@@ -260,8 +262,8 @@ export declare namespace IRandomGenerator {
          */
         integer?: (schema: OpenApi.IJsonSchema.IInteger & Record<string, any>) => number;
         /**
-         * Custom bigint generator that can handle special bigint constraints
-         * based on schema properties.
+         * Custom bigint generator that can handle special bigint constraints based
+         * on schema properties.
          */
         bigint?: (schema: OpenApi.IJsonSchema.IInteger & Record<string, any>) => bigint;
         /**
@@ -270,8 +272,8 @@ export declare namespace IRandomGenerator {
          */
         boolean?: (schema: Record<string, any>) => boolean | undefined;
         /**
-         * Custom array generator that can handle special array constraints
-         * based on schema properties.
+         * Custom array generator that can handle special array constraints based on
+         * schema properties.
          */
         array?: <T>(schema: Omit<OpenApi.IJsonSchema.IArray, "items"> & {
             element: (index: number, count: number) => T;

package/lib/IReadableURLSearchParams.d.mts

@@ -1,8 +1,8 @@
 /**
  * Interface for a readable URLSearchParams object.
  *
- * This interface is a subset of the {@link URLSearchParams} interface,
- * designed especially for the [Hono.JS](https://hono.dev/) library.
+ * This interface is a subset of the {@link URLSearchParams} interface, designed
+ * especially for the [Hono.JS](https://hono.dev/) library.
  *
  * @author https://github.com/miyaji255
  */

package/lib/IReadableURLSearchParams.d.ts

@@ -1,8 +1,8 @@
 /**
  * Interface for a readable URLSearchParams object.
  *
- * This interface is a subset of the {@link URLSearchParams} interface,
- * designed especially for the [Hono.JS](https://hono.dev/) library.
+ * This interface is a subset of the {@link URLSearchParams} interface, designed
+ * especially for the [Hono.JS](https://hono.dev/) library.
  *
  * @author https://github.com/miyaji255
  */

package/lib/PascalCase.d.mts

@@ -9,8 +9,8 @@ import { ValueOf } from "./typings/ValueOf";
  *
  * It also erases every method property like {@link Resolved} type.
  *
- * @template T Target type to be pascalized
  * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to be pascalized
  */
 export type PascalCase<T> = Equal<T, PascalizeMain<T>> extends true ? T : PascalizeMain<T>;
 type PascalizeMain<T> = T extends [never] ? never : T extends {

package/lib/PascalCase.d.ts

@@ -9,8 +9,8 @@ import { ValueOf } from "./typings/ValueOf";
  *
  * It also erases every method property like {@link Resolved} type.
  *
- * @template T Target type to be pascalized
  * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to be pascalized
  */
 export type PascalCase<T> = Equal<T, PascalizeMain<T>> extends true ? T : PascalizeMain<T>;
 type PascalizeMain<T> = T extends [never] ? never : T extends {

package/lib/Primitive.d.mts

@@ -6,36 +6,34 @@ import { Format } from "./tags";
 /**
  * Primitive type of JSON.
  *
- * `Primitive<T>` is a TMP (Type Meta Programming) type which converts
- * its argument as a primitive type within the framework JSON.
+ * `Primitive<T>` is a TMP (Type Meta Programming) type which converts its
+ * argument as a primitive type within the framework JSON.
  *
- * If the target argument is a built-in class which returns its origin primitive type
- * through the `valueOf()` method like the `String` or `Number`, its return type will
- * be the `string` or `number`. Otherwise, if the built-in class does not have the
- * `valueOf()` method, the return type will be an empty object (`{}`).
+ * If the target argument is a built-in class which returns its origin primitive
+ * type through the `valueOf()` method like the `String` or `Number`, its return
+ * type will be the `string` or `number`. Otherwise, if the built-in class does
+ * not have the `valueOf()` method, the return type will be an empty object
+ * (`{}`).
  *
- * Otherwise, if the target argument is a type of custom class, all of its custom methods
- * will be erased and its prototype will be changed to the primitive `object`.
- * Therefore, the return type of the TMP type will finally be the primitive object.
+ * Otherwise, if the target argument is a type of custom class, all of its
+ * custom methods will be erased and its prototype will be changed to the
+ * primitive `object`. Therefore, the return type of the TMP type will finally
+ * be the primitive object.
  *
- * In addition, if the target argument is a type of custom class and it has a special
- * method `toJSON()`, the return type of this `Primitive` will be not `Primitive<Instance>`
- * but `Primitive<ReturnType<Instance.toJSON>>`.
+ * In addition, if the target argument is a type of custom class and it has a
+ * special method `toJSON()`, the return type of this `Primitive` will be not
+ * `Primitive<Instance>` but `Primitive<ReturnType<Instance.toJSON>>`.
  *
- * Before                  | After
- * ------------------------|----------------------------------------
- * `Boolean`               | `boolean`
- * `Number`                | `number`
- * `String`                | `string`
- * `Class`                 | `object`
- * `Class` with `toJSON()` | `Primitive<ReturnType<Class.toJSON>>`
- * Native Class            | never
- * Others                  | No change
+ * Before | After
+ * ------------------------|---------------------------------------- `Boolean` |
+ * `boolean` `Number` | `number` `String` | `string` `Class` | `object` `Class`
+ * with `toJSON()` | `Primitive<ReturnType<Class.toJSON>>` Native Class | never
+ * Others | No change
  *
- * @template T Target argument type.
  * @author Jeongho Nam - https://github.com/samchon
  * @author Kyungsu Kang - https://github.com/kakasoo
  * @author Michael - https://github.com/8471919
+ * @template T Target argument type.
  */
 export type Primitive<T> = Equal<T, PrimitiveMain<T>> extends true ? T : PrimitiveMain<T>;
 type PrimitiveMain<Instance> = Instance extends [never] ? never : ValueOf<Instance> extends bigint ? never : ValueOf<Instance> extends boolean | number | string ? ValueOf<Instance> : Instance extends Function ? never : ValueOf<Instance> extends object ? Instance extends object ? Instance extends Date ? string & Format<"date-time"> : Instance extends IJsonable<infer Raw> ? ValueOf<Raw> extends object ? Raw extends object ? PrimitiveObject<Raw> : never : ValueOf<Raw> : Instance extends Exclude<NativeClass, Date> ? never : PrimitiveObject<Instance> : never : ValueOf<Instance>;

package/lib/Primitive.d.ts

@@ -6,36 +6,34 @@ import { Format } from "./tags";
 /**
  * Primitive type of JSON.
  *
- * `Primitive<T>` is a TMP (Type Meta Programming) type which converts
- * its argument as a primitive type within the framework JSON.
+ * `Primitive<T>` is a TMP (Type Meta Programming) type which converts its
+ * argument as a primitive type within the framework JSON.
  *
- * If the target argument is a built-in class which returns its origin primitive type
- * through the `valueOf()` method like the `String` or `Number`, its return type will
- * be the `string` or `number`. Otherwise, if the built-in class does not have the
- * `valueOf()` method, the return type will be an empty object (`{}`).
+ * If the target argument is a built-in class which returns its origin primitive
+ * type through the `valueOf()` method like the `String` or `Number`, its return
+ * type will be the `string` or `number`. Otherwise, if the built-in class does
+ * not have the `valueOf()` method, the return type will be an empty object
+ * (`{}`).
  *
- * Otherwise, if the target argument is a type of custom class, all of its custom methods
- * will be erased and its prototype will be changed to the primitive `object`.
- * Therefore, the return type of the TMP type will finally be the primitive object.
+ * Otherwise, if the target argument is a type of custom class, all of its
+ * custom methods will be erased and its prototype will be changed to the
+ * primitive `object`. Therefore, the return type of the TMP type will finally
+ * be the primitive object.
  *
- * In addition, if the target argument is a type of custom class and it has a special
- * method `toJSON()`, the return type of this `Primitive` will be not `Primitive<Instance>`
- * but `Primitive<ReturnType<Instance.toJSON>>`.
+ * In addition, if the target argument is a type of custom class and it has a
+ * special method `toJSON()`, the return type of this `Primitive` will be not
+ * `Primitive<Instance>` but `Primitive<ReturnType<Instance.toJSON>>`.
  *
- * Before                  | After
- * ------------------------|----------------------------------------
- * `Boolean`               | `boolean`
- * `Number`                | `number`
- * `String`                | `string`
- * `Class`                 | `object`
- * `Class` with `toJSON()` | `Primitive<ReturnType<Class.toJSON>>`
- * Native Class            | never
- * Others                  | No change
+ * Before | After
+ * ------------------------|---------------------------------------- `Boolean` |
+ * `boolean` `Number` | `number` `String` | `string` `Class` | `object` `Class`
+ * with `toJSON()` | `Primitive<ReturnType<Class.toJSON>>` Native Class | never
+ * Others | No change
  *
- * @template T Target argument type.
  * @author Jeongho Nam - https://github.com/samchon
  * @author Kyungsu Kang - https://github.com/kakasoo
  * @author Michael - https://github.com/8471919
+ * @template T Target argument type.
  */
 export type Primitive<T> = Equal<T, PrimitiveMain<T>> extends true ? T : PrimitiveMain<T>;
 type PrimitiveMain<Instance> = Instance extends [never] ? never : ValueOf<Instance> extends bigint ? never : ValueOf<Instance> extends boolean | number | string ? ValueOf<Instance> : Instance extends Function ? never : ValueOf<Instance> extends object ? Instance extends object ? Instance extends Date ? string & Format<"date-time"> : Instance extends IJsonable<infer Raw> ? ValueOf<Raw> extends object ? Raw extends object ? PrimitiveObject<Raw> : never : ValueOf<Raw> : Instance extends Exclude<NativeClass, Date> ? never : PrimitiveObject<Instance> : never : ValueOf<Instance>;

package/lib/Resolved.d.mts

@@ -5,30 +5,28 @@ import { ValueOf } from "./typings/ValueOf";
 /**
  * Resolved type that erases every method.
  *
- * `Resolved` is a TMP (Type Meta Programming) type which converts
- * its argument as a resolved type that erases every method property.
+ * `Resolved` is a TMP (Type Meta Programming) type which converts its argument
+ * as a resolved type that erases every method property.
  *
- * If the target argument is a built-in class which returns its origin primitive type
- * through the `valueOf()` method like the `String` or `Number`, its return type will
- * be the `string` or `number`. Otherwise, if the built-in class does not have the
- * `valueOf()` method, the return type will be the same as the target argument.
+ * If the target argument is a built-in class which returns its origin primitive
+ * type through the `valueOf()` method like the `String` or `Number`, its return
+ * type will be the `string` or `number`. Otherwise, if the built-in class does
+ * not have the `valueOf()` method, the return type will be the same as the
+ * target argument.
  *
- * Otherwise, if the target argument is a type of custom class, all of its custom methods
- * will be erased and its prototype will be changed to the primitive `object`.
- * Therefore, the return type of the TMP type will finally be the resolved object.
+ * Otherwise, if the target argument is a type of custom class, all of its
+ * custom methods will be erased and its prototype will be changed to the
+ * primitive `object`. Therefore, the return type of the TMP type will finally
+ * be the resolved object.
  *
- * Before                  | After
- * ------------------------|----------------------------------------
- * `Boolean`               | `boolean`
- * `Number`                | `number`
- * `BigInt`                | `bigint`
- * `String`                | `string`
- * `Class`                 | `interface`
- * Native Class or Others  | No change
+ * Before | After
+ * ------------------------|---------------------------------------- `Boolean` |
+ * `boolean` `Number` | `number` `BigInt` | `bigint` `String` | `string` `Class`
+ * | `interface` Native Class or Others | No change
  *
- * @template T Target argument type.
  * @author Jeongho Nam - https://github.com/samchon
  * @author Kyungsu Kang - https://github.com/kakasoo
+ * @template T Target argument type.
  */
 export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true ? T : ResolvedMain<T>;
 type ResolvedMain<T> = T extends [never] ? never : ValueOf<T> extends boolean | number | bigint | string ? ValueOf<T> : T extends Function ? never : T extends object ? ResolvedObject<T> : ValueOf<T>;