@typia/interface 12.0.0-dev.20260309 → 12.0.0-dev.20260310

package/src/typings/PascalCase.ts

@@ -1,71 +1,71 @@
-import { Equal } from "./internal/Equal";
-import { IsTuple } from "./internal/IsTuple";
-import { NativeClass } from "./internal/NativeClass";
-import { ValueOf } from "./internal/ValueOf";
-
-/**
- * Converts all object keys to PascalCase.
- *
- * `PascalCase<T>` transforms object property names to PascalCase format and
- * erases methods like {@link Resolved}. Recursively processes nested
- * structures.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @template T Target type to transform
- */
-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 "./internal/Equal";
+import { IsTuple } from "./internal/IsTuple";
+import { NativeClass } from "./internal/NativeClass";
+import { ValueOf } from "./internal/ValueOf";
+
+/**
+ * Converts all object keys to PascalCase.
+ *
+ * `PascalCase<T>` transforms object property names to PascalCase format and
+ * erases methods like {@link Resolved}. Recursively processes nested
+ * structures.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to transform
+ */
+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/typings/Primitive.ts

@@ -1,71 +1,71 @@
-import { Format } from "../tags/Format";
-import { Equal } from "./internal/Equal";
-import { IsTuple } from "./internal/IsTuple";
-import { NativeClass } from "./internal/NativeClass";
-import { ValueOf } from "./internal/ValueOf";
-
-/**
- * Converts a type to its JSON-serializable primitive form.
- *
- * `Primitive<T>` transforms types for JSON serialization: boxed primitives
- * become primitives (Boolean→boolean), classes become plain objects with
- * methods removed, Date becomes `string & Format<"date-time">`, and types with
- * `toJSON()` use their return type. Native classes (except Date) and bigint
- * become `never` as they're not JSON-serializable.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @author Kyungsu Kang - https://github.com/kakasoo
- * @author Michael - https://github.com/8471919
- * @template T Target type to convert
- */
-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 { Format } from "../tags/Format";
+import { Equal } from "./internal/Equal";
+import { IsTuple } from "./internal/IsTuple";
+import { NativeClass } from "./internal/NativeClass";
+import { ValueOf } from "./internal/ValueOf";
+
+/**
+ * Converts a type to its JSON-serializable primitive form.
+ *
+ * `Primitive<T>` transforms types for JSON serialization: boxed primitives
+ * become primitives (Boolean→boolean), classes become plain objects with
+ * methods removed, Date becomes `string & Format<"date-time">`, and types with
+ * `toJSON()` use their return type. Native classes (except Date) and bigint
+ * become `never` as they're not JSON-serializable.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ * @author Michael - https://github.com/8471919
+ * @template T Target type to convert
+ */
+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/typings/ProtobufAtomic.ts

@@ -1,30 +1,30 @@
-/**
- * Protocol Buffers atomic (scalar) type names.
- *
- * Union of all primitive type identifiers used in Protocol Buffers wire format
- * encoding/decoding.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export type ProtobufAtomic =
-  | "bool"
-  | "int32"
-  | "uint32"
-  | "int64"
-  | "uint64"
-  | "float"
-  | "double"
-  | "string";
-export namespace ProtobufAtomic {
-  /** Numeric protobuf types (integers and floats). */
-  export type Numeric =
-    | "int32"
-    | "uint32"
-    | "int64"
-    | "uint64"
-    | "float"
-    | "double";
-
-  /** 64-bit integer types that map to JavaScript `bigint`. */
-  export type BigNumeric = "int64" | "uint64";
-}
+/**
+ * Protocol Buffers atomic (scalar) type names.
+ *
+ * Union of all primitive type identifiers used in Protocol Buffers wire format
+ * encoding/decoding.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type ProtobufAtomic =
+  | "bool"
+  | "int32"
+  | "uint32"
+  | "int64"
+  | "uint64"
+  | "float"
+  | "double"
+  | "string";
+export namespace ProtobufAtomic {
+  /** Numeric protobuf types (integers and floats). */
+  export type Numeric =
+    | "int32"
+    | "uint32"
+    | "int64"
+    | "uint64"
+    | "float"
+    | "double";
+
+  /** 64-bit integer types that map to JavaScript `bigint`. */
+  export type BigNumeric = "int64" | "uint64";
+}

package/src/typings/Resolved.ts

@@ -1,58 +1,58 @@
-import { Equal } from "./internal/Equal";
-import { IsTuple } from "./internal/IsTuple";
-import { NativeClass } from "./internal/NativeClass";
-import { ValueOf } from "./internal/ValueOf";
-
-/**
- * Converts a type to its resolved form by erasing all methods.
- *
- * `Resolved<T>` transforms classes to plain objects, extracts primitive values
- * from boxed types (Boolean→boolean, Number→number, String→string), and
- * recursively processes nested structures. Native classes (Date, Set, Map,
- * etc.) are preserved unchanged.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @author Kyungsu Kang - https://github.com/kakasoo
- * @template T Target type to resolve
- */
-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 "./internal/Equal";
+import { IsTuple } from "./internal/IsTuple";
+import { NativeClass } from "./internal/NativeClass";
+import { ValueOf } from "./internal/ValueOf";
+
+/**
+ * Converts a type to its resolved form by erasing all methods.
+ *
+ * `Resolved<T>` transforms classes to plain objects, extracts primitive values
+ * from boxed types (Boolean→boolean, Number→number, String→string), and
+ * recursively processes nested structures. Native classes (Date, Set, Map,
+ * etc.) are preserved unchanged.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ * @template T Target type to resolve
+ */
+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>]
+          : [];