typia 7.6.2-dev.20250205 → 7.6.2

package/src/IRandomGenerator.ts

@@ -1,49 +1,49 @@
-import { OpenApi } from "@samchon/openapi";
-
-export interface IRandomGenerator {
-  // REGULAR
-  boolean(): boolean | undefined;
-  number(schema: OpenApi.IJsonSchema.INumber): number;
-  integer(schema: OpenApi.IJsonSchema.IInteger): number;
-  bigint(schema: OpenApi.IJsonSchema.IInteger): bigint;
-  string(schema: OpenApi.IJsonSchema.IString): string;
-  array<T>(
-    schema: Omit<OpenApi.IJsonSchema.IArray, "items"> & {
-      element: (index: number, count: number) => T;
-    },
-  ): T[];
-  pattern(regex: RegExp): string;
-
-  //----
-  // FORMAT
-  //----
-  // SPECIAL CHARACTERS
-  byte(): string;
-  password(): string;
-  regex(): string;
-  uuid(): string;
-
-  // ADDRESSES
-  email(): string;
-  hostname(): string;
-  idnEmail(): string;
-  idnHostname(): string;
-  iri(): string;
-  iriReference(): string;
-  ipv4(): string;
-  ipv6(): string;
-  uri(): string;
-  uriReference(): string;
-  uriTemplate(): string;
-  url(): string;
-
-  // TIMESTAMPS
-  datetime(props?: { minimum?: number; maximum?: number }): string;
-  date(props?: { minimum?: number; maximum?: number }): string;
-  time(): string;
-  duration(): string;
-
-  // POINTERS
-  jsonPointer(): string;
-  relativeJsonPointer(): string;
-}
+import { OpenApi } from "@samchon/openapi";
+
+export interface IRandomGenerator {
+  // REGULAR
+  boolean(): boolean | undefined;
+  number(schema: OpenApi.IJsonSchema.INumber): number;
+  integer(schema: OpenApi.IJsonSchema.IInteger): number;
+  bigint(schema: OpenApi.IJsonSchema.IInteger): bigint;
+  string(schema: OpenApi.IJsonSchema.IString): string;
+  array<T>(
+    schema: Omit<OpenApi.IJsonSchema.IArray, "items"> & {
+      element: (index: number, count: number) => T;
+    },
+  ): T[];
+  pattern(regex: RegExp): string;
+
+  //----
+  // FORMAT
+  //----
+  // SPECIAL CHARACTERS
+  byte(): string;
+  password(): string;
+  regex(): string;
+  uuid(): string;
+
+  // ADDRESSES
+  email(): string;
+  hostname(): string;
+  idnEmail(): string;
+  idnHostname(): string;
+  iri(): string;
+  iriReference(): string;
+  ipv4(): string;
+  ipv6(): string;
+  uri(): string;
+  uriReference(): string;
+  uriTemplate(): string;
+  url(): string;
+
+  // TIMESTAMPS
+  datetime(props?: { minimum?: number; maximum?: number }): string;
+  date(props?: { minimum?: number; maximum?: number }): string;
+  time(): string;
+  duration(): string;
+
+  // POINTERS
+  jsonPointer(): string;
+  relativeJsonPointer(): string;
+}

package/src/IReadableURLSearchParams.ts

@@ -1,9 +1,9 @@
-/**
- * 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.
- *
- * @author https://github.com/miyaji255
- */
-export type IReadableURLSearchParams = Pick<URLSearchParams, "get" | "getAll">;
+/**
+ * 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.
+ *
+ * @author https://github.com/miyaji255
+ */
+export type IReadableURLSearchParams = Pick<URLSearchParams, "get" | "getAll">;

package/src/IValidation.ts

@@ -1,21 +1,21 @@
-export type IValidation<T = unknown> =
-  | IValidation.ISuccess<T>
-  | IValidation.IFailure;
-export namespace IValidation {
-  export interface ISuccess<T = unknown> {
-    success: true;
-    data: T;
-  }
-
-  export interface IFailure {
-    success: false;
-    errors: IError[];
-    data: unknown;
-  }
-
-  export interface IError {
-    path: string;
-    expected: string;
-    value: any;
-  }
-}
+export type IValidation<T = unknown> =
+  | IValidation.ISuccess<T>
+  | IValidation.IFailure;
+export namespace IValidation {
+  export interface ISuccess<T = unknown> {
+    success: true;
+    data: T;
+  }
+
+  export interface IFailure {
+    success: false;
+    errors: IError[];
+    data: unknown;
+  }
+
+  export interface IError {
+    path: string;
+    expected: string;
+    value: any;
+  }
+}

package/src/PascalCase.ts

@@ -1,71 +1,71 @@
-import { Equal } from "./typings/Equal";
-import { IsTuple } from "./typings/IsTuple";
-import { NativeClass } from "./typings/NativeClass";
-import { ValueOf } from "./typings/ValueOf";
-
-/**
- * Pascal case type.
- *
- * `PascalCase` type is a type that all keys of an object are pascalized.
- *
- * It also erase every method properties like {@link Resolved} type.
- *
- * @template T Target type to be pascalized
- * @author Jeongho Nam - https://github.com/samchon
- */
-export type PascalCase<T> =
-  Equal<T, PascalizeMain<T>> extends true ? T : PascalizeMain<T>;
-
-type PascalizeMain<T> = T extends [never]
-  ? never // special trick for (jsonable | null) type
-  : T extends { valueOf(): boolean | bigint | number | string }
-    ? ValueOf<T>
-    : T extends Function
-      ? never
-      : T extends object
-        ? PascalizeObject<T>
-        : T;
-
-type PascalizeObject<T extends object> =
-  T extends Array<infer U>
-    ? IsTuple<T> extends true
-      ? PascalizeTuple<T>
-      : PascalizeMain<U>[]
-    : T extends Set<infer U>
-      ? Set<PascalizeMain<U>>
-      : T extends Map<infer K, infer V>
-        ? Map<PascalizeMain<K>, PascalizeMain<V>>
-        : T extends WeakSet<any> | WeakMap<any, any>
-          ? never
-          : T extends NativeClass
-            ? T
-            : {
-                [Key in keyof T as PascalizeString<
-                  Key & string
-                >]: PascalizeMain<T[Key]>;
-              };
-
-type PascalizeTuple<T extends readonly any[]> = T extends []
-  ? []
-  : T extends [infer F]
-    ? [PascalizeMain<F>]
-    : T extends [infer F, ...infer Rest extends readonly any[]]
-      ? [PascalizeMain<F>, ...PascalizeTuple<Rest>]
-      : T extends [(infer F)?]
-        ? [PascalizeMain<F>?]
-        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-          ? [PascalizeMain<F>?, ...PascalizeTuple<Rest>]
-          : [];
-
-type PascalizeString<Key extends string> = Key extends `_${infer R}`
-  ? `_${PascalizeString<R>}`
-  : Key extends `${infer _F}_${infer _R}`
-    ? PascalizeSnakeString<Key>
-    : Capitalize<Key>;
-type PascalizeSnakeString<Key extends string> = Key extends `_${infer R}`
-  ? PascalizeSnakeString<R>
-  : Key extends `${infer F}${infer M}_${infer R}`
-    ? `${Uppercase<F>}${Lowercase<M>}${PascalizeSnakeString<R>}`
-    : Key extends `${infer F}${infer R}`
-      ? `${Uppercase<F>}${Lowercase<R>}`
-      : Key;
+import { Equal } from "./typings/Equal";
+import { IsTuple } from "./typings/IsTuple";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+
+/**
+ * Pascal case type.
+ *
+ * `PascalCase` type is a type that all keys of an object are pascalized.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be pascalized
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type PascalCase<T> =
+  Equal<T, PascalizeMain<T>> extends true ? T : PascalizeMain<T>;
+
+type PascalizeMain<T> = T extends [never]
+  ? never // special trick for (jsonable | null) type
+  : T extends { valueOf(): boolean | bigint | number | string }
+    ? ValueOf<T>
+    : T extends Function
+      ? never
+      : T extends object
+        ? PascalizeObject<T>
+        : T;
+
+type PascalizeObject<T extends object> =
+  T extends Array<infer U>
+    ? IsTuple<T> extends true
+      ? PascalizeTuple<T>
+      : PascalizeMain<U>[]
+    : T extends Set<infer U>
+      ? Set<PascalizeMain<U>>
+      : T extends Map<infer K, infer V>
+        ? Map<PascalizeMain<K>, PascalizeMain<V>>
+        : T extends WeakSet<any> | WeakMap<any, any>
+          ? never
+          : T extends NativeClass
+            ? T
+            : {
+                [Key in keyof T as PascalizeString<
+                  Key & string
+                >]: PascalizeMain<T[Key]>;
+              };
+
+type PascalizeTuple<T extends readonly any[]> = T extends []
+  ? []
+  : T extends [infer F]
+    ? [PascalizeMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+      ? [PascalizeMain<F>, ...PascalizeTuple<Rest>]
+      : T extends [(infer F)?]
+        ? [PascalizeMain<F>?]
+        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+          ? [PascalizeMain<F>?, ...PascalizeTuple<Rest>]
+          : [];
+
+type PascalizeString<Key extends string> = Key extends `_${infer R}`
+  ? `_${PascalizeString<R>}`
+  : Key extends `${infer _F}_${infer _R}`
+    ? PascalizeSnakeString<Key>
+    : Capitalize<Key>;
+type PascalizeSnakeString<Key extends string> = Key extends `_${infer R}`
+  ? PascalizeSnakeString<R>
+  : Key extends `${infer F}${infer M}_${infer R}`
+    ? `${Uppercase<F>}${Lowercase<M>}${PascalizeSnakeString<R>}`
+    : Key extends `${infer F}${infer R}`
+      ? `${Uppercase<F>}${Lowercase<R>}`
+      : Key;

package/src/Primitive.ts

@@ -1,92 +1,92 @@
-import { Equal } from "./typings/Equal";
-import { IsTuple } from "./typings/IsTuple";
-import { NativeClass } from "./typings/NativeClass";
-import { ValueOf } from "./typings/ValueOf";
-
-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 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 would
- * be the `string` or `number`. Otherwise, the built-in class does not have the
- * `valueOf()` method, the return type would be an empty object (`{}`).
- *
- * Otherwise, the target argument is a type of custom class, all of its custom method
- * would be erased and its prototype would be changed to the primitive `object`.
- * Therefore, return type of the TMP type finally be the primitive object.
- *
- * In addition, if the target argument is a type of custom class and it has a special
- * method `toJSON()`, return type of this `Primitive` would 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
- *
- * @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
- */
-export type Primitive<T> =
-  Equal<T, PrimitiveMain<T>> extends true ? T : PrimitiveMain<T>;
-
-type PrimitiveMain<Instance> = Instance extends [never]
-  ? never // (special trick for jsonable | null) type
-  : 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> // object would be primitified
-                    : never // cannot be
-                  : ValueOf<Raw> // atomic value
-                : Instance extends Exclude<NativeClass, Date>
-                  ? never
-                  : PrimitiveObject<Instance> // object would be primitified
-            : never // cannot be
-          : ValueOf<Instance>;
-
-type PrimitiveObject<Instance extends object> =
-  Instance extends Array<infer T>
-    ? IsTuple<Instance> extends true
-      ? PrimitiveTuple<Instance>
-      : PrimitiveMain<T>[]
-    : {
-        [P in keyof Instance]: PrimitiveMain<Instance[P]>;
-      };
-
-type PrimitiveTuple<T extends readonly any[]> = T extends []
-  ? []
-  : T extends [infer F]
-    ? [PrimitiveMain<F>]
-    : T extends [infer F, ...infer Rest extends readonly any[]]
-      ? [PrimitiveMain<F>, ...PrimitiveTuple<Rest>]
-      : T extends [(infer F)?]
-        ? [PrimitiveMain<F>?]
-        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-          ? [PrimitiveMain<F>?, ...PrimitiveTuple<Rest>]
-          : [];
-
-interface IJsonable<T> {
-  toJSON(): T;
-}
+import { Equal } from "./typings/Equal";
+import { IsTuple } from "./typings/IsTuple";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+
+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 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 would
+ * be the `string` or `number`. Otherwise, the built-in class does not have the
+ * `valueOf()` method, the return type would be an empty object (`{}`).
+ *
+ * Otherwise, the target argument is a type of custom class, all of its custom method
+ * would be erased and its prototype would be changed to the primitive `object`.
+ * Therefore, return type of the TMP type finally be the primitive object.
+ *
+ * In addition, if the target argument is a type of custom class and it has a special
+ * method `toJSON()`, return type of this `Primitive` would 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
+ *
+ * @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
+ */
+export type Primitive<T> =
+  Equal<T, PrimitiveMain<T>> extends true ? T : PrimitiveMain<T>;
+
+type PrimitiveMain<Instance> = Instance extends [never]
+  ? never // (special trick for jsonable | null) type
+  : 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> // object would be primitified
+                    : never // cannot be
+                  : ValueOf<Raw> // atomic value
+                : Instance extends Exclude<NativeClass, Date>
+                  ? never
+                  : PrimitiveObject<Instance> // object would be primitified
+            : never // cannot be
+          : ValueOf<Instance>;
+
+type PrimitiveObject<Instance extends object> =
+  Instance extends Array<infer T>
+    ? IsTuple<Instance> extends true
+      ? PrimitiveTuple<Instance>
+      : PrimitiveMain<T>[]
+    : {
+        [P in keyof Instance]: PrimitiveMain<Instance[P]>;
+      };
+
+type PrimitiveTuple<T extends readonly any[]> = T extends []
+  ? []
+  : T extends [infer F]
+    ? [PrimitiveMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+      ? [PrimitiveMain<F>, ...PrimitiveTuple<Rest>]
+      : T extends [(infer F)?]
+        ? [PrimitiveMain<F>?]
+        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+          ? [PrimitiveMain<F>?, ...PrimitiveTuple<Rest>]
+          : [];
+
+interface IJsonable<T> {
+  toJSON(): T;
+}

package/src/Resolved.ts

@@ -1,74 +1,74 @@
-import { Equal } from "./typings/Equal";
-import { IsTuple } from "./typings/IsTuple";
-import { NativeClass } from "./typings/NativeClass";
-import { ValueOf } from "./typings/ValueOf";
-
-/**
- * Resolved type erased every methods.
- *
- * `Resolved` is a type of TMP (Type Meta Programming) type which converts
- * its argument as a resolved type that erased every method properties.
- *
- * 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 would
- * be the `string` or `number`. Otherwise, the built-in class does not have the
- * `valueOf()` method, the return type would be same with the target argument.
- *
- * Otherwise, the target argument is a type of custom class, all of its custom methods
- * would be erased and its prototype would be changed to the primitive `object`.
- * Therefore, return type of the TMP type finally be the resolved object.
- *
- * 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
- */
-export type Resolved<T> =
-  Equal<T, ResolvedMain<T>> extends true ? T : ResolvedMain<T>;
-
-type ResolvedMain<T> = T extends [never]
-  ? never // (special trick for jsonable | null) type
-  : ValueOf<T> extends boolean | number | bigint | string
-    ? ValueOf<T>
-    : T extends Function
-      ? never
-      : T extends object
-        ? ResolvedObject<T>
-        : ValueOf<T>;
-
-type ResolvedObject<T extends object> =
-  T extends Array<infer U>
-    ? IsTuple<T> extends true
-      ? ResolvedTuple<T>
-      : ResolvedMain<U>[]
-    : T extends Set<infer U>
-      ? Set<ResolvedMain<U>>
-      : T extends Map<infer K, infer V>
-        ? Map<ResolvedMain<K>, ResolvedMain<V>>
-        : T extends WeakSet<any> | WeakMap<any, any>
-          ? never
-          : T extends NativeClass
-            ? T
-            : {
-                [P in keyof T]: ResolvedMain<T[P]>;
-              };
-
-type ResolvedTuple<T extends readonly any[]> = T extends []
-  ? []
-  : T extends [infer F]
-    ? [ResolvedMain<F>]
-    : T extends [infer F, ...infer Rest extends readonly any[]]
-      ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
-      : T extends [(infer F)?]
-        ? [ResolvedMain<F>?]
-        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-          ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
-          : [];
+import { Equal } from "./typings/Equal";
+import { IsTuple } from "./typings/IsTuple";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+
+/**
+ * Resolved type erased every methods.
+ *
+ * `Resolved` is a type of TMP (Type Meta Programming) type which converts
+ * its argument as a resolved type that erased every method properties.
+ *
+ * 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 would
+ * be the `string` or `number`. Otherwise, the built-in class does not have the
+ * `valueOf()` method, the return type would be same with the target argument.
+ *
+ * Otherwise, the target argument is a type of custom class, all of its custom methods
+ * would be erased and its prototype would be changed to the primitive `object`.
+ * Therefore, return type of the TMP type finally be the resolved object.
+ *
+ * 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
+ */
+export type Resolved<T> =
+  Equal<T, ResolvedMain<T>> extends true ? T : ResolvedMain<T>;
+
+type ResolvedMain<T> = T extends [never]
+  ? never // (special trick for jsonable | null) type
+  : ValueOf<T> extends boolean | number | bigint | string
+    ? ValueOf<T>
+    : T extends Function
+      ? never
+      : T extends object
+        ? ResolvedObject<T>
+        : ValueOf<T>;
+
+type ResolvedObject<T extends object> =
+  T extends Array<infer U>
+    ? IsTuple<T> extends true
+      ? ResolvedTuple<T>
+      : ResolvedMain<U>[]
+    : T extends Set<infer U>
+      ? Set<ResolvedMain<U>>
+      : T extends Map<infer K, infer V>
+        ? Map<ResolvedMain<K>, ResolvedMain<V>>
+        : T extends WeakSet<any> | WeakMap<any, any>
+          ? never
+          : T extends NativeClass
+            ? T
+            : {
+                [P in keyof T]: ResolvedMain<T[P]>;
+              };
+
+type ResolvedTuple<T extends readonly any[]> = T extends []
+  ? []
+  : T extends [infer F]
+    ? [ResolvedMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+      ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
+      : T extends [(infer F)?]
+        ? [ResolvedMain<F>?]
+        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+          ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
+          : [];