typia 9.7.1 → 10.0.0-dev.20251107

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 Jeongho Nam
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2022 Jeongho Nam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,153 +1,153 @@
-# Typia
-![Typia Logo](https://typia.io/logo.png)
-
-[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/typia/blob/master/LICENSE)
-[![NPM Version](https://img.shields.io/npm/v/typia.svg)](https://www.npmjs.com/package/typia)
-[![NPM Downloads](https://img.shields.io/npm/dm/typia.svg)](https://www.npmjs.com/package/typia)
-[![Build Status](https://github.com/samchon/typia/workflows/build/badge.svg)](https://github.com/samchon/typia/actions?query=workflow%3Abuild)
-[![Guide Documents](https://img.shields.io/badge/Guide-Documents-forestgreen)](https://typia.io/docs/)
-[![Gurubase](https://img.shields.io/badge/Gurubase-Document%20Chatbot-006BFF)](https://gurubase.io/g/typia)
-[![Discord Badge](https://img.shields.io/badge/discord-samchon-d91965?style=flat&labelColor=5866f2&logo=discord&logoColor=white&link=https://discord.gg/E94XhzrUCZ)](https://discord.gg/E94XhzrUCZ)
-
-```typescript
-// RUNTIME VALIDATORS
-export function is<T>(input: unknown): input is T; // returns boolean
-export function assert<T>(input: unknown): T; // throws TypeGuardError
-export function assertGuard<T>(input: unknown): asserts input is T;
-export function validate<T>(input: unknown): IValidation<T>; // detailed
-
-// JSON FUNCTIONS
-export namespace json {
-  export function application<T>(): IJsonApplication; // JSON schema
-  export function assertParse<T>(input: string): T; // type safe parser
-  export function assertStringify<T>(input: T): string; // safe and faster
-}
-
-// AI FUNCTION CALLING SCHEMA
-export namespace llm {
-  // collection of function calling schemas
-  export function application<Class, Model>(): ILlmApplication<Class>;
-  export function controller<Class, Model>(
-    name: string,
-    execute: Class,
-  ): ILlmController<Model>; // +executor
-  // structured output
-  export function parameters<P, Model>(): ILlmSchema.IParameters<Model>; 
-  export function schema<T, Model>(): ILlmSchema<Model>; // type schema
-}
-
-// PROTOCOL BUFFER
-export namespace protobuf {
-  export function message<T>(): string; // Protocol Buffer message
-  export function assertDecode<T>(buffer: Uint8Array): T; // safe decoder
-  export function assertEncode<T>(input: T): Uint8Array; // safe encoder
-}
-
-// RANDOM GENERATOR
-export function random<T>(g?: Partial<IRandomGenerator>): T;
-```
-
-`typia` is a transformer library supporting below features:
-
-  - Super-fast Runtime Validators
-  - Enhanced JSON schema and serde functions
-  - LLM function calling schema and structured output
-  - Protocol Buffer encoder and decoder
-  - Random data generator
-
-> [!NOTE]
->
-> - **Only one line** required, with pure TypeScript type
-> - Runtime validator is **20,000x faster** than `class-validator`
-> - JSON serialization is **200x faster** than `class-transformer`
-
-
-
-
-## Transformation
-If you call `typia` function, it would be compiled like below.
-
-This is the key concept of `typia`, transforming TypeScript type to a runtime function. The `typia.is<T>()` function is transformed to a dedicated type checker by analyzing the target type `T` in the compilation level.
-
-This feature enables developers to ensure type safety in their applications, leveraging TypeScript's static typing while also providing runtime validation. Instead of defining additional schemas, you can simply utilize the pure TypeScript type itself.
-
-```typescript
-//----
-// examples/checkString.ts
-//----
-import typia, { tags } from "typia";
-export const checkString = typia.createIs<string>();
-
-//----
-// examples/checkString.js
-//----
-import typia from "typia";
-export const checkString = (() => {
-  return (input) => "string" === typeof input;
-})();
-```
-
-
-
-## Sponsors
-Thanks for your support.
-
-Your donation encourages `typia` development.
-
-Also, `typia` is re-distributing half of donations to core contributors of `typia`.
-
-  - [`nonara/ts-patch`](https://github.com/nonara/ts-patch)
-  - [`ryoppippi/unplugin-typia`](https://github.com/ryoppippi/unplugin-typia)
-
-[![Sponsors](https://opencollective.com/typia/badge.svg?avatarHeight=75&width=600)](https://opencollective.com/typia)
-
-
-
-
-## Playground
-You can experience how typia works by [playground website](https://typia.io/playground):
-
-  - 💻 https://typia.io/playground
-
-
-
-
-## Guide Documents
-Check out the document in the [website](https://typia.io/docs/):
-
-### 🏠 Home
-  - [Introduction](https://typia.io/docs/)
-  - [Setup](https://typia.io/docs/setup/)
-  - [Pure TypeScript](https://typia.io/docs/pure/)
-  
-### 📖 Features
-  - Runtime Validators
-    - [`assert()` function](https://typia.io/docs/validators/assert/)
-    - [`is()` function](https://typia.io/docs/validators/is/)
-    - [`validate()` function](https://typia.io/docs/validators/validate/)
-    - [Functional Module](https://typia.io/docs/validators/functional)
-    - [Special Tags](https://typia.io/docs/validators/tags/)
-  - Enhanced JSON
-    - [JSON Schema](https://typia.io/docs/json/schema/)
-    - [`stringify()` functions](https://typia.io/docs/json/stringify/)
-    - [`parse()` functions](https://typia.io/docs/json/parse/)
-  - LLM Function Calling
-    - [`application()` function](https://typia.io/docs/llm/application/)
-    - [`parameters()` function](https://typia.io/docs/llm/parameters/)
-    - [`schema()` function](https://typia.io/docs/llm/schema/)
-    - [AI Chatbot Development](https://typia.io/docs/llm/chat/)
-    - [Documentation Strategy](https://typia.io/docs/llm/strategy/)
-  - Protocol Buffer
-    - [Message Schema](https://typia.io/docs/protobuf/message)
-    - [`decode()` functions](https://typia.io/docs/protobuf/decode/)
-    - [`encode()` functions](https://typia.io/docs/protobuf/encode/)
-  - [Random Generator](https://typia.io/docs/random/)
-  - [Miscellaneous](https://typia.io/docs/misc/)
-
-### 🔗 Appendix
-  - [API Documents](https://typia.io/api)
-  - Utillization Cases
-    - [NestJS](https://typia.io/docs/utilization/nestjs/)
-    - [tRPC](https://typia.io/docs/utilization/trpc/)
-  - [⇲ Benchmark Result](https://github.com/samchon/typia/tree/master/benchmark/results/11th%20Gen%20Intel(R)%20Core(TM)%20i5-1135G7%20%40%202.40GHz)
-  - [⇲ `dev.to` Articles](https://dev.to/samchon/series/22474)
+# Typia
+![Typia Logo](https://typia.io/logo.png)
+
+[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/typia/blob/master/LICENSE)
+[![NPM Version](https://img.shields.io/npm/v/typia.svg)](https://www.npmjs.com/package/typia)
+[![NPM Downloads](https://img.shields.io/npm/dm/typia.svg)](https://www.npmjs.com/package/typia)
+[![Build Status](https://github.com/samchon/typia/workflows/build/badge.svg)](https://github.com/samchon/typia/actions?query=workflow%3Abuild)
+[![Guide Documents](https://img.shields.io/badge/Guide-Documents-forestgreen)](https://typia.io/docs/)
+[![Gurubase](https://img.shields.io/badge/Gurubase-Document%20Chatbot-006BFF)](https://gurubase.io/g/typia)
+[![Discord Badge](https://img.shields.io/badge/discord-samchon-d91965?style=flat&labelColor=5866f2&logo=discord&logoColor=white&link=https://discord.gg/E94XhzrUCZ)](https://discord.gg/E94XhzrUCZ)
+
+```typescript
+// RUNTIME VALIDATORS
+export function is<T>(input: unknown): input is T; // returns boolean
+export function assert<T>(input: unknown): T; // throws TypeGuardError
+export function assertGuard<T>(input: unknown): asserts input is T;
+export function validate<T>(input: unknown): IValidation<T>; // detailed
+
+// JSON FUNCTIONS
+export namespace json {
+  export function application<T>(): IJsonApplication; // JSON schema
+  export function assertParse<T>(input: string): T; // type safe parser
+  export function assertStringify<T>(input: T): string; // safe and faster
+}
+
+// AI FUNCTION CALLING SCHEMA
+export namespace llm {
+  // collection of function calling schemas
+  export function application<Class, Model>(): ILlmApplication<Class>;
+  export function controller<Class, Model>(
+    name: string,
+    execute: Class,
+  ): ILlmController<Model>; // +executor
+  // structured output
+  export function parameters<P, Model>(): ILlmSchema.IParameters<Model>; 
+  export function schema<T, Model>(): ILlmSchema<Model>; // type schema
+}
+
+// PROTOCOL BUFFER
+export namespace protobuf {
+  export function message<T>(): string; // Protocol Buffer message
+  export function assertDecode<T>(buffer: Uint8Array): T; // safe decoder
+  export function assertEncode<T>(input: T): Uint8Array; // safe encoder
+}
+
+// RANDOM GENERATOR
+export function random<T>(g?: Partial<IRandomGenerator>): T;
+```
+
+`typia` is a transformer library supporting below features:
+
+  - Super-fast Runtime Validators
+  - Enhanced JSON schema and serde functions
+  - LLM function calling schema and structured output
+  - Protocol Buffer encoder and decoder
+  - Random data generator
+
+> [!NOTE]
+>
+> - **Only one line** required, with pure TypeScript type
+> - Runtime validator is **20,000x faster** than `class-validator`
+> - JSON serialization is **200x faster** than `class-transformer`
+
+
+
+
+## Transformation
+If you call `typia` function, it would be compiled like below.
+
+This is the key concept of `typia`, transforming TypeScript type to a runtime function. The `typia.is<T>()` function is transformed to a dedicated type checker by analyzing the target type `T` in the compilation level.
+
+This feature enables developers to ensure type safety in their applications, leveraging TypeScript's static typing while also providing runtime validation. Instead of defining additional schemas, you can simply utilize the pure TypeScript type itself.
+
+```typescript
+//----
+// examples/checkString.ts
+//----
+import typia, { tags } from "typia";
+export const checkString = typia.createIs<string>();
+
+//----
+// examples/checkString.js
+//----
+import typia from "typia";
+export const checkString = (() => {
+  return (input) => "string" === typeof input;
+})();
+```
+
+
+
+## Sponsors
+Thanks for your support.
+
+Your donation encourages `typia` development.
+
+Also, `typia` is re-distributing half of donations to core contributors of `typia`.
+
+  - [`nonara/ts-patch`](https://github.com/nonara/ts-patch)
+  - [`ryoppippi/unplugin-typia`](https://github.com/ryoppippi/unplugin-typia)
+
+[![Sponsors](https://opencollective.com/typia/badge.svg?avatarHeight=75&width=600)](https://opencollective.com/typia)
+
+
+
+
+## Playground
+You can experience how typia works by [playground website](https://typia.io/playground):
+
+  - 💻 https://typia.io/playground
+
+
+
+
+## Guide Documents
+Check out the document in the [website](https://typia.io/docs/):
+
+### 🏠 Home
+  - [Introduction](https://typia.io/docs/)
+  - [Setup](https://typia.io/docs/setup/)
+  - [Pure TypeScript](https://typia.io/docs/pure/)
+  
+### 📖 Features
+  - Runtime Validators
+    - [`assert()` function](https://typia.io/docs/validators/assert/)
+    - [`is()` function](https://typia.io/docs/validators/is/)
+    - [`validate()` function](https://typia.io/docs/validators/validate/)
+    - [Functional Module](https://typia.io/docs/validators/functional)
+    - [Special Tags](https://typia.io/docs/validators/tags/)
+  - Enhanced JSON
+    - [JSON Schema](https://typia.io/docs/json/schema/)
+    - [`stringify()` functions](https://typia.io/docs/json/stringify/)
+    - [`parse()` functions](https://typia.io/docs/json/parse/)
+  - LLM Function Calling
+    - [`application()` function](https://typia.io/docs/llm/application/)
+    - [`parameters()` function](https://typia.io/docs/llm/parameters/)
+    - [`schema()` function](https://typia.io/docs/llm/schema/)
+    - [AI Chatbot Development](https://typia.io/docs/llm/chat/)
+    - [Documentation Strategy](https://typia.io/docs/llm/strategy/)
+  - Protocol Buffer
+    - [Message Schema](https://typia.io/docs/protobuf/message)
+    - [`decode()` functions](https://typia.io/docs/protobuf/decode/)
+    - [`encode()` functions](https://typia.io/docs/protobuf/encode/)
+  - [Random Generator](https://typia.io/docs/random/)
+  - [Miscellaneous](https://typia.io/docs/misc/)
+
+### 🔗 Appendix
+  - [API Documents](https://typia.io/api)
+  - Utilization Cases
+    - [NestJS](https://typia.io/docs/utilization/nestjs/)
+    - [tRPC](https://typia.io/docs/utilization/trpc/)
+  - [⇲ Benchmark Result](https://github.com/samchon/typia/tree/master/benchmark/results/11th%20Gen%20Intel(R)%20Core(TM)%20i5-1135G7%20%40%202.40GHz)
+  - [⇲ `dev.to` Articles](https://dev.to/samchon/series/22474)

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;