@typia/interface 12.0.0-dev.20260307-2 → 12.0.0-dev.20260310

package/src/tags/Type.ts

@@ -1,70 +1,70 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Numeric precision and bit-width type constraint.
- *
- * `Type<Value>` is a type tag that constrains numeric values to specific
- * bit-width representations. This is essential for Protocol Buffers
- * serialization and ensures values fit within their specified ranges.
- *
- * Available types:
- *
- * - `"int32"`: Signed 32-bit integer (-2,147,483,648 to 2,147,483,647)
- * - `"uint32"`: Unsigned 32-bit integer (0 to 4,294,967,295)
- * - `"int64"`: Signed 64-bit integer (for `number` or `bigint`)
- * - `"uint64"`: Unsigned 64-bit integer (for `number` or `bigint`)
- * - `"float"`: 32-bit floating point
- * - `"double"`: 64-bit floating point (default JavaScript number)
- *
- * For Protocol Buffers, integer types also determine the wire encoding. The
- * constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It generates appropriate `type` in JSON Schema.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Message {
- *     // 32-bit unsigned integer
- *     id: number & Type<"uint32">;
- *     // 64-bit signed integer as bigint
- *     timestamp: bigint & Type<"int64">;
- *     // 32-bit float for memory efficiency
- *     score: number & Type<"float">;
- *   }
- *
- * @template Value Numeric type identifier
- */
-export type Type<
-  Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double",
-> = TagBase<{
-  target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
-  kind: "type";
-  value: Value;
-  validate: Value extends "int32"
-    ? `$importInternal("isTypeInt32")($input)`
-    : Value extends "uint32"
-      ? `$importInternal("isTypeUint32")($input)`
-      : Value extends "int64"
-        ? {
-            number: `$importInternal("isTypeInt64")($input)`;
-            bigint: `true`;
-          }
-        : Value extends "uint64"
-          ? {
-              number: `$importInternal("isTypeUint64")($input)`;
-              bigint: `BigInt(0) <= $input`;
-            }
-          : Value extends "float"
-            ? `$importInternal("isTypeFloat")($input)`
-            : `true`;
-  exclusive: true;
-  schema: Value extends "uint32" | "uint64"
-    ? {
-        type: "integer";
-        minimum: 0;
-      }
-    : {
-        type: Value extends "int32" | "uint32" | "int64" | "uint64"
-          ? "integer"
-          : "number";
-      };
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * Numeric precision and bit-width type constraint.
+ *
+ * `Type<Value>` is a type tag that constrains numeric values to specific
+ * bit-width representations. This is essential for Protocol Buffers
+ * serialization and ensures values fit within their specified ranges.
+ *
+ * Available types:
+ *
+ * - `"int32"`: Signed 32-bit integer (-2,147,483,648 to 2,147,483,647)
+ * - `"uint32"`: Unsigned 32-bit integer (0 to 4,294,967,295)
+ * - `"int64"`: Signed 64-bit integer (for `number` or `bigint`)
+ * - `"uint64"`: Unsigned 64-bit integer (for `number` or `bigint`)
+ * - `"float"`: 32-bit floating point
+ * - `"double"`: 64-bit floating point (default JavaScript number)
+ *
+ * For Protocol Buffers, integer types also determine the wire encoding. The
+ * constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates appropriate `type` in JSON Schema.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Message {
+ *     // 32-bit unsigned integer
+ *     id: number & Type<"uint32">;
+ *     // 64-bit signed integer as bigint
+ *     timestamp: bigint & Type<"int64">;
+ *     // 32-bit float for memory efficiency
+ *     score: number & Type<"float">;
+ *   }
+ *
+ * @template Value Numeric type identifier
+ */
+export type Type<
+  Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double",
+> = TagBase<{
+  target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
+  kind: "type";
+  value: Value;
+  validate: Value extends "int32"
+    ? `$importInternal("isTypeInt32")($input)`
+    : Value extends "uint32"
+      ? `$importInternal("isTypeUint32")($input)`
+      : Value extends "int64"
+        ? {
+            number: `$importInternal("isTypeInt64")($input)`;
+            bigint: `true`;
+          }
+        : Value extends "uint64"
+          ? {
+              number: `$importInternal("isTypeUint64")($input)`;
+              bigint: `BigInt(0) <= $input`;
+            }
+          : Value extends "float"
+            ? `$importInternal("isTypeFloat")($input)`
+            : `true`;
+  exclusive: true;
+  schema: Value extends "uint32" | "uint64"
+    ? {
+        type: "integer";
+        minimum: 0;
+      }
+    : {
+        type: Value extends "int32" | "uint32" | "int64" | "uint64"
+          ? "integer"
+          : "number";
+      };
+}>;

package/src/tags/UniqueItems.ts

@@ -1,44 +1,44 @@
-import { TagBase } from "./TagBase";
-
-/**
- * Array unique elements constraint.
- *
- * `UniqueItems` is a type tag that validates all elements in an array are
- * unique (no duplicates). Apply it to array properties using TypeScript
- * intersection types.
- *
- * Uniqueness is determined by:
- *
- * - **Primitives**: Strict equality (`===`)
- * - **Objects**: Deep structural comparison
- *
- * This constraint is commonly combined with {@link MinItems} and {@link MaxItems}
- * for comprehensive array validation. It's useful for modeling set-like data
- * that must be represented as arrays in JSON.
- *
- * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
- * `typia.validate()`. It generates `uniqueItems: true` in JSON Schema.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   interface Preferences {
- *     // No duplicate tags allowed
- *     tags: (string & UniqueItems)[];
- *     // Unique user IDs
- *     favoriteUserIds: (number & UniqueItems)[];
- *   }
- *
- * @template Value Boolean flag, defaults to `true` (enable constraint)
- */
-export type UniqueItems<Value extends boolean = true> = TagBase<{
-  target: "array";
-  kind: "uniqueItems";
-  value: Value;
-  validate: Value extends true
-    ? `$importInternal("isUniqueItems")($input)`
-    : undefined;
-  exclusive: true;
-  schema: {
-    uniqueItems: true;
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+/**
+ * Array unique elements constraint.
+ *
+ * `UniqueItems` is a type tag that validates all elements in an array are
+ * unique (no duplicates). Apply it to array properties using TypeScript
+ * intersection types.
+ *
+ * Uniqueness is determined by:
+ *
+ * - **Primitives**: Strict equality (`===`)
+ * - **Objects**: Deep structural comparison
+ *
+ * This constraint is commonly combined with {@link MinItems} and {@link MaxItems}
+ * for comprehensive array validation. It's useful for modeling set-like data
+ * that must be represented as arrays in JSON.
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `uniqueItems: true` in JSON Schema.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Preferences {
+ *     // No duplicate tags allowed
+ *     tags: (string & UniqueItems)[];
+ *     // Unique user IDs
+ *     favoriteUserIds: (number & UniqueItems)[];
+ *   }
+ *
+ * @template Value Boolean flag, defaults to `true` (enable constraint)
+ */
+export type UniqueItems<Value extends boolean = true> = TagBase<{
+  target: "array";
+  kind: "uniqueItems";
+  value: Value;
+  validate: Value extends true
+    ? `$importInternal("isUniqueItems")($input)`
+    : undefined;
+  exclusive: true;
+  schema: {
+    uniqueItems: true;
+  };
+}>;

package/src/tags/index.ts

@@ -1,21 +1,21 @@
-export * from "./Constant";
-export * from "./ContentMediaType";
-export * from "./Default";
-export * from "./Example";
-export * from "./Examples";
-export * from "./ExclusiveMaximum";
-export * from "./ExclusiveMinimum";
-export * from "./Format";
-export * from "./JsonSchemaPlugin";
-export * from "./Maximum";
-export * from "./MaxItems";
-export * from "./MaxLength";
-export * from "./Minimum";
-export * from "./MinItems";
-export * from "./MinLength";
-export * from "./MultipleOf";
-export * from "./Pattern";
-export * from "./Sequence";
-export * from "./TagBase";
-export * from "./Type";
-export * from "./UniqueItems";
+export * from "./Constant";
+export * from "./ContentMediaType";
+export * from "./Default";
+export * from "./Example";
+export * from "./Examples";
+export * from "./ExclusiveMaximum";
+export * from "./ExclusiveMinimum";
+export * from "./Format";
+export * from "./JsonSchemaPlugin";
+export * from "./Maximum";
+export * from "./MaxItems";
+export * from "./MaxLength";
+export * from "./Minimum";
+export * from "./MinItems";
+export * from "./MinLength";
+export * from "./MultipleOf";
+export * from "./Pattern";
+export * from "./Sequence";
+export * from "./TagBase";
+export * from "./Type";
+export * from "./UniqueItems";

package/src/typings/AssertionGuard.ts

@@ -1,12 +1,12 @@
-/**
- * Type for assertion guard functions that narrow input type.
- *
- * `AssertionGuard<T>` is a function type that validates input at runtime and
- * asserts it as type `T`. Unlike regular assertions that return the value,
- * assertion guards return void but narrow the input parameter's type.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @template T Target type to assert
- * @throws {TypeGuardError} When validation fails
- */
-export type AssertionGuard<T> = (input: unknown) => asserts input is T;
+/**
+ * Type for assertion guard functions that narrow input type.
+ *
+ * `AssertionGuard<T>` is a function type that validates input at runtime and
+ * asserts it as type `T`. Unlike regular assertions that return the value,
+ * assertion guards return void but narrow the input parameter's type.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to assert
+ * @throws {TypeGuardError} When validation fails
+ */
+export type AssertionGuard<T> = (input: unknown) => asserts input is T;

package/src/typings/Atomic.ts

@@ -1,21 +1,21 @@
-/**
- * Atomic (primitive) type utilities for typia's type system.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace Atomic {
-  /** Union of JavaScript primitive value types. */
-  export type Type = boolean | number | string | bigint;
-
-  /** String literal names for atomic types. */
-  export type Literal = "boolean" | "integer" | "number" | "string" | "bigint";
-
-  /** Maps literal type names to their corresponding value types. */
-  export type Mapper = {
-    boolean: boolean;
-    integer: number;
-    number: number;
-    string: string;
-    bigint: bigint;
-  };
-}
+/**
+ * Atomic (primitive) type utilities for typia's type system.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace Atomic {
+  /** Union of JavaScript primitive value types. */
+  export type Type = boolean | number | string | bigint;
+
+  /** String literal names for atomic types. */
+  export type Literal = "boolean" | "integer" | "number" | "string" | "bigint";
+
+  /** Maps literal type names to their corresponding value types. */
+  export type Mapper = {
+    boolean: boolean;
+    integer: number;
+    number: number;
+    string: string;
+    bigint: bigint;
+  };
+}

package/src/typings/CamelCase.ts

@@ -1,75 +1,75 @@
-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 camelCase.
- *
- * `CamelCase<T>` transforms object property names to camelCase 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 CamelCase<T> =
-  Equal<T, CamelizeMain<T>> extends true ? T : CamelizeMain<T>;
-
-type CamelizeMain<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
-        ? CamelizeObject<T>
-        : T;
-
-type CamelizeObject<T extends object> =
-  T extends Array<infer U>
-    ? IsTuple<T> extends true
-      ? CamelizeTuple<T>
-      : CamelizeMain<U>[]
-    : T extends Set<infer U>
-      ? Set<CamelizeMain<U>>
-      : T extends Map<infer K, infer V>
-        ? Map<CamelizeMain<K>, CamelizeMain<V>>
-        : T extends WeakSet<any> | WeakMap<any, any>
-          ? never
-          : T extends NativeClass
-            ? T
-            : {
-                [Key in keyof T as CamelizeString<Key & string>]: CamelizeMain<
-                  T[Key]
-                >;
-              };
-
-type CamelizeTuple<T extends readonly any[]> = T extends []
-  ? []
-  : T extends [infer F]
-    ? [CamelizeMain<F>]
-    : T extends [infer F, ...infer Rest extends readonly any[]]
-      ? [CamelizeMain<F>, ...CamelizeTuple<Rest>]
-      : T extends [(infer F)?]
-        ? [CamelizeMain<F>?]
-        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-          ? [CamelizeMain<F>?, ...CamelizeTuple<Rest>]
-          : [];
-
-type CamelizeString<Key extends string> = Key extends `_${infer R}`
-  ? `_${CamelizeString<R>}`
-  : Key extends `${infer _F}_${infer _R}`
-    ? CamelizeSnakeString<Key>
-    : Key extends Uppercase<Key>
-      ? Lowercase<Key>
-      : CamelizePascalString<Key>;
-type CamelizePascalString<Key extends string> =
-  Key extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : Key;
-type CamelizeSnakeString<Key extends string> = Key extends `_${infer R}`
-  ? CamelizeSnakeString<R>
-  : Key extends `${infer F}_${infer M}${infer R}`
-    ? M extends "_"
-      ? CamelizeSnakeString<`${F}_${R}`>
-      : `${Lowercase<F>}${Uppercase<M>}${CamelizeSnakeString<R>}`
-    : Lowercase<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 camelCase.
+ *
+ * `CamelCase<T>` transforms object property names to camelCase 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 CamelCase<T> =
+  Equal<T, CamelizeMain<T>> extends true ? T : CamelizeMain<T>;
+
+type CamelizeMain<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
+        ? CamelizeObject<T>
+        : T;
+
+type CamelizeObject<T extends object> =
+  T extends Array<infer U>
+    ? IsTuple<T> extends true
+      ? CamelizeTuple<T>
+      : CamelizeMain<U>[]
+    : T extends Set<infer U>
+      ? Set<CamelizeMain<U>>
+      : T extends Map<infer K, infer V>
+        ? Map<CamelizeMain<K>, CamelizeMain<V>>
+        : T extends WeakSet<any> | WeakMap<any, any>
+          ? never
+          : T extends NativeClass
+            ? T
+            : {
+                [Key in keyof T as CamelizeString<Key & string>]: CamelizeMain<
+                  T[Key]
+                >;
+              };
+
+type CamelizeTuple<T extends readonly any[]> = T extends []
+  ? []
+  : T extends [infer F]
+    ? [CamelizeMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+      ? [CamelizeMain<F>, ...CamelizeTuple<Rest>]
+      : T extends [(infer F)?]
+        ? [CamelizeMain<F>?]
+        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+          ? [CamelizeMain<F>?, ...CamelizeTuple<Rest>]
+          : [];
+
+type CamelizeString<Key extends string> = Key extends `_${infer R}`
+  ? `_${CamelizeString<R>}`
+  : Key extends `${infer _F}_${infer _R}`
+    ? CamelizeSnakeString<Key>
+    : Key extends Uppercase<Key>
+      ? Lowercase<Key>
+      : CamelizePascalString<Key>;
+type CamelizePascalString<Key extends string> =
+  Key extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : Key;
+type CamelizeSnakeString<Key extends string> = Key extends `_${infer R}`
+  ? CamelizeSnakeString<R>
+  : Key extends `${infer F}_${infer M}${infer R}`
+    ? M extends "_"
+      ? CamelizeSnakeString<`${F}_${R}`>
+      : `${Lowercase<F>}${Uppercase<M>}${CamelizeSnakeString<R>}`
+    : Lowercase<Key>;

package/src/typings/ClassProperties.ts

@@ -1,15 +1,15 @@
-import { OmitNever } from "./OmitNever";
-
-/**
- * Extracts non-function properties from a class type.
- *
- * `ClassProperties<T>` filters out all method properties from a class, keeping
- * only data properties. Useful for serialization where methods should be
- * excluded.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @template T Target class type
- */
-export type ClassProperties<T extends object> = OmitNever<{
-  [K in keyof T]: T[K] extends Function ? never : T[K];
-}>;
+import { OmitNever } from "./OmitNever";
+
+/**
+ * Extracts non-function properties from a class type.
+ *
+ * `ClassProperties<T>` filters out all method properties from a class, keeping
+ * only data properties. Useful for serialization where methods should be
+ * excluded.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target class type
+ */
+export type ClassProperties<T extends object> = OmitNever<{
+  [K in keyof T]: T[K] extends Function ? never : T[K];
+}>;

package/src/typings/DeepPartial.ts

@@ -1,39 +1,39 @@
-/**
- * Recursively makes all properties of a type optional.
- *
- * `DeepPartial<T>` transforms a type by making every property optional at all
- * nesting levels. Unlike TypeScript's built-in `Partial<T>` which only affects
- * the top level, this utility recursively applies optionality to nested objects
- * and arrays.
- *
- * Used primarily in {@link IJsonParseResult.IFailure} to represent partially
- * recovered data from malformed JSON, where some properties may be missing due
- * to parsing errors.
- *
- * Behavior:
- *
- * - **Primitives** (`string`, `number`, `boolean`, `bigint`, `symbol`, `null`,
- *   `undefined`): returned as-is
- * - **Functions**: returned as-is
- * - **Arrays**: element type becomes `DeepPartial<U>`
- * - **Objects**: all properties become optional with `DeepPartial` applied
- *
- * @author Michael - https://github.com/8471919
- * @template T The type to make deeply partial
- */
-export type DeepPartial<T> = T extends
-  | string
-  | number
-  | boolean
-  | bigint
-  | symbol
-  | null
-  | undefined
-  ? T
-  : T extends (...args: unknown[]) => unknown
-    ? T
-    : T extends Array<infer U>
-      ? Array<DeepPartial<U>>
-      : T extends object
-        ? { [P in keyof T]?: DeepPartial<T[P]> }
-        : T;
+/**
+ * Recursively makes all properties of a type optional.
+ *
+ * `DeepPartial<T>` transforms a type by making every property optional at all
+ * nesting levels. Unlike TypeScript's built-in `Partial<T>` which only affects
+ * the top level, this utility recursively applies optionality to nested objects
+ * and arrays.
+ *
+ * Used primarily in {@link IJsonParseResult.IFailure} to represent partially
+ * recovered data from malformed JSON, where some properties may be missing due
+ * to parsing errors.
+ *
+ * Behavior:
+ *
+ * - **Primitives** (`string`, `number`, `boolean`, `bigint`, `symbol`, `null`,
+ *   `undefined`): returned as-is
+ * - **Functions**: returned as-is
+ * - **Arrays**: element type becomes `DeepPartial<U>`
+ * - **Objects**: all properties become optional with `DeepPartial` applied
+ *
+ * @author Michael - https://github.com/8471919
+ * @template T The type to make deeply partial
+ */
+export type DeepPartial<T> = T extends
+  | string
+  | number
+  | boolean
+  | bigint
+  | symbol
+  | null
+  | undefined
+  ? T
+  : T extends (...args: unknown[]) => unknown
+    ? T
+    : T extends Array<infer U>
+      ? Array<DeepPartial<U>>
+      : T extends object
+        ? { [P in keyof T]?: DeepPartial<T[P]> }
+        : T;

package/src/typings/OmitNever.ts

@@ -1,12 +1,12 @@
-import { SpecialFields } from "./SpecialFields";
-
-/**
- * Omits properties with `never` type from an object type.
- *
- * `OmitNever<T>` removes all properties whose value type is `never`, producing
- * a cleaner type without impossible properties.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @template T Target object type
- */
-export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;
+import { SpecialFields } from "./SpecialFields";
+
+/**
+ * Omits properties with `never` type from an object type.
+ *
+ * `OmitNever<T>` removes all properties whose value type is `never`, producing
+ * a cleaner type without impossible properties.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target object type
+ */
+export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;