@typia/interface 12.0.0-dev.20260225

package/src/tags/Minimum.ts

@@ -0,0 +1,44 @@
+import { TagBase } from "./TagBase";
+
+/**
+ * Inclusive minimum value constraint (value >= min).
+ *
+ * `Minimum<N>` is a type tag that validates numeric values are greater than or
+ * equal to the specified bound. Apply it to `number` or `bigint` properties
+ * using TypeScript intersection types.
+ *
+ * This constraint is **mutually exclusive** with {@link ExclusiveMinimum} - you
+ * cannot use both on the same property. Use `Minimum` for inclusive bounds (>=)
+ * and `ExclusiveMinimum` for exclusive bounds (>).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It also generates `minimum` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Product {
+ *     // Price must be 0 or greater
+ *     price: number & Minimum<0>;
+ *     // Quantity must be at least 1
+ *     quantity: number & Minimum<1>;
+ *   }
+ *
+ * @template Value The minimum allowed value (inclusive)
+ */
+export type Minimum<Value extends number | bigint> = TagBase<{
+  target: Value extends bigint ? "bigint" : "number";
+  kind: "minimum";
+  value: Value;
+  validate: `${Cast<Value>} <= $input`;
+  exclusive: ["minimum", "exclusiveMinimum"];
+  schema: Value extends bigint
+    ? { minimum: Numeric<Value> }
+    : { minimum: Value };
+}>;
+
+type Cast<Value extends number | bigint> = Value extends number
+  ? Value
+  : `BigInt(${Value})`;
+type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
+  ? N
+  : never;

package/src/tags/MultipleOf.ts

@@ -0,0 +1,54 @@
+import { TagBase } from "./TagBase";
+
+/**
+ * Divisibility constraint (value % divisor === 0).
+ *
+ * `MultipleOf<N>` is a type tag that validates numeric values are exactly
+ * divisible by the specified divisor with no remainder. Apply it to `number` or
+ * `bigint` properties using TypeScript intersection types.
+ *
+ * Common use cases:
+ *
+ * - `MultipleOf<2>` for even numbers
+ * - `MultipleOf<0.01>` for currency with 2 decimal places
+ * - `MultipleOf<100>` for values in hundreds
+ *
+ * This constraint can be combined with other numeric constraints like
+ * {@link Minimum} and {@link Maximum}. Multiple `MultipleOf` constraints on the
+ * same property are allowed (all must pass).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `multipleOf` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Currency {
+ *     // Must be exact cents (0.01, 0.02, ..., 1.00, 1.01, ...)
+ *     amount: number & MultipleOf<0.01>;
+ *   }
+ *   interface Pagination {
+ *     // Page size must be multiple of 10
+ *     pageSize: number & MultipleOf<10>;
+ *   }
+ *
+ * @template Value The divisor (value must be evenly divisible by this)
+ */
+export type MultipleOf<Value extends number | bigint> = TagBase<{
+  target: Value extends bigint ? "bigint" : "number";
+  kind: "multipleOf";
+  value: Value;
+  validate: `$input % ${Cast<Value>} === ${Value extends bigint
+    ? Cast<0n>
+    : 0}`;
+  exclusive: true;
+  schema: Value extends bigint
+    ? { multipleOf: Numeric<Value> }
+    : { multipleOf: Value };
+}>;
+
+type Cast<Value extends number | bigint> = Value extends number
+  ? Value
+  : `BigInt(${Value})`;
+type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
+  ? N
+  : never;

package/src/tags/Pattern.ts

@@ -0,0 +1,59 @@
+import { TagBase } from "./TagBase";
+
+/**
+ * Regular expression pattern constraint for strings.
+ *
+ * `Pattern<Regex>` is a type tag that validates string values match the
+ * specified regular expression pattern. Apply it to `string` properties using
+ * TypeScript intersection types.
+ *
+ * This constraint is **mutually exclusive** with {@link Format} - you cannot use
+ * both on the same property. Use `Pattern` for custom regex validation, or
+ * `Format` for standard formats (email, uuid, etc.).
+ *
+ * The pattern should be a valid JavaScript regular expression string without
+ * the surrounding slashes. The entire string must match (implicit `^` and `$`
+ * anchors).
+ *
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `pattern` in JSON Schema output.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Product {
+ *     // SKU format: 3 letters, dash, 4 digits
+ *     sku: string & Pattern<"^[A-Z]{3}-[0-9]{4}$">;
+ *     // Phone number: digits and optional dashes
+ *     phone: string & Pattern<"^[0-9-]+$">;
+ *   }
+ *
+ * @template Value Regular expression pattern as a string literal
+ */
+export type Pattern<Value extends string> = TagBase<{
+  target: "string";
+  kind: "pattern";
+  value: Value;
+  validate: `RegExp("${Serialize<Value>}").test($input)`;
+  exclusive: ["format", "pattern"];
+  schema: {
+    pattern: Value;
+  };
+}>;
+
+type Serialize<T extends string, Output extends string = ""> = string extends T
+  ? never
+  : T extends ""
+    ? Output
+    : T extends `${infer P}${infer R}`
+      ? Serialize<R, `${Output}${P extends keyof Escaper ? Escaper[P] : P}`>
+      : never;
+
+type Escaper = {
+  '"': '\\"';
+  "\\": "\\\\";
+  "\b": "\\b";
+  "\f": "\\f";
+  "\n": "\\n";
+  "\r": "\\r";
+  "\t": "\\t";
+};

package/src/tags/Sequence.ts

@@ -0,0 +1,43 @@
+import { TagBase } from "./TagBase";
+
+/**
+ * Protocol Buffer field number assignment.
+ *
+ * `Sequence<N>` is a type tag that assigns a unique field number for Protocol
+ * Buffer serialization. In protobuf, each field in a message must have a unique
+ * numeric identifier that's used in the binary encoding.
+ *
+ * Field number guidelines:
+ *
+ * - **1-15**: Use one byte in encoding (ideal for frequently-used fields)
+ * - **16-2047**: Use two bytes
+ * - **2048-536,870,911**: Use more bytes (avoid for efficiency)
+ * - **19000-19999**: Reserved by Protocol Buffers (cannot use)
+ *
+ * If not specified, typia auto-assigns field numbers. Use `Sequence` when you
+ * need stable field numbers for backward compatibility or when integrating with
+ * existing protobuf schemas.
+ *
+ * This tag is used by `typia.protobuf.encode()` and `typia.protobuf.decode()`.
+ * The field number also appears in JSON Schema as `x-protobuf-sequence`.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Message {
+ *     // Frequently accessed fields use low numbers
+ *     id: (number & Sequence<1>) & Type<"uint32">;
+ *     name: string & Sequence<2>;
+ *     // Less common fields use higher numbers
+ *     metadata: (Record<string, string> & Sequence<100>) | undefined;
+ *   }
+ *
+ * @template N Field number (1 to 536,870,911, excluding 19000-19999)
+ */
+export type Sequence<N extends number> = TagBase<{
+  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+  kind: "sequence";
+  value: N;
+  schema: {
+    "x-protobuf-sequence": N;
+  };
+}>;

package/src/tags/TagBase.ts

@@ -0,0 +1,131 @@
+/**
+ * Base type for all typia validation tags.
+ *
+ * `TagBase` is the foundation for all typia type tags (constraints like
+ * `Minimum`, `MaxLength`, `Format`, etc.). It attaches compile-time metadata to
+ * TypeScript types using a phantom property pattern.
+ *
+ * The typia transformer reads these tags at compile time and generates
+ * appropriate runtime validation code. The tags themselves have no runtime
+ * presence - they exist only in the type system.
+ *
+ * This is an internal implementation detail. Use the specific tag types (e.g.,
+ * {@link Minimum}, {@link Format}, {@link Pattern}) rather than `TagBase`
+ * directly.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template Props Tag properties defining validation behavior and schema output
+ */
+export type TagBase<
+  Props extends TagBase.IProps<any, any, any, any, any, any>,
+> = {
+  /**
+   * Compile-time marker property for typia transformer.
+   *
+   * This phantom property carries tag metadata in the type system. It is never
+   * assigned at runtime - it exists only for the transformer to read during
+   * compilation.
+   */
+  "typia.tag"?: Props;
+};
+export namespace TagBase {
+  /**
+   * Configuration interface for validation tag properties.
+   *
+   * Defines all the metadata a validation tag can specify, including what types
+   * it applies to, how to validate values, and what to output in JSON Schema.
+   *
+   * @template Target Which primitive type(s) this tag can be applied to
+   * @template Kind Unique identifier for this tag type
+   * @template Value The constraint value specified by the user
+   * @template Validate The validation expression to generate
+   * @template Exclusive Whether this tag conflicts with others
+   * @template Schema Additional JSON Schema properties to output
+   */
+  export interface IProps<
+    Target extends
+      | "boolean"
+      | "bigint"
+      | "number"
+      | "string"
+      | "array"
+      | "object",
+    Kind extends string,
+    Value extends boolean | bigint | number | string | undefined,
+    Validate extends
+      | string
+      | {
+          [key in Target]?: string;
+        },
+    Exclusive extends boolean | string[],
+    Schema extends object | undefined,
+  > {
+    /**
+     * Target primitive type(s) this tag applies to.
+     *
+     * The transformer will error if the tag is applied to a property of a
+     * different type. For example, `MinLength` targets `"string"` and cannot be
+     * applied to numbers.
+     */
+    target: Target;
+
+    /**
+     * Unique identifier for this tag type.
+     *
+     * Used internally to identify the constraint kind. Examples: `"minimum"`,
+     * `"maxLength"`, `"format"`, `"pattern"`.
+     */
+    kind: Kind;
+
+    /**
+     * User-configured constraint value.
+     *
+     * The value provided by the user when applying the tag. For `Minimum<5>`,
+     * this would be `5`. For `Format<"email">`, this would be `"email"`.
+     */
+    value: Value;
+
+    /**
+     * Validation expression template.
+     *
+     * JavaScript expression string that validates the input value. Use `$input`
+     * as a placeholder for the actual value. The expression is inserted into
+     * the generated validation function.
+     *
+     * Can be a single string or an object mapping target types to different
+     * expressions (for tags supporting multiple types).
+     *
+     * @example
+     *   `"5 <= $input"`; // For Minimum<5>
+     *
+     * @example
+     *   `"$input.length <= 10"`; // For MaxLength<10>
+     */
+    validate?: Validate;
+
+    /**
+     * Tag exclusivity configuration.
+     *
+     * Controls which other tags cannot be combined with this one:
+     *
+     * - `true`: No duplicate tags of the same kind allowed
+     * - `string[]`: List of incompatible tag kinds
+     * - `false` (default): No exclusivity restrictions
+     *
+     * For example, `Minimum` and `ExclusiveMinimum` are mutually exclusive -
+     * only one can be applied to a property.
+     *
+     * @default false
+     */
+    exclusive?: Exclusive | string[];
+
+    /**
+     * Additional JSON Schema properties to output.
+     *
+     * Object containing schema properties to merge into the generated JSON
+     * Schema for the annotated type. For `Minimum<5>`, this would be `{
+     * minimum: 5 }`.
+     */
+    schema?: Schema;
+  }
+}

package/src/tags/Type.ts

@@ -0,0 +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";
+      };
+}>;

package/src/tags/UniqueItems.ts

@@ -0,0 +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;
+  };
+}>;

package/src/tags/index.ts

@@ -0,0 +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";

package/src/typings/AssertionGuard.ts

@@ -0,0 +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;

package/src/typings/Atomic.ts

@@ -0,0 +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;
+  };
+}

package/src/typings/CamelCase.ts

@@ -0,0 +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>;

package/src/typings/ClassProperties.ts

@@ -0,0 +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];
+}>;

package/src/typings/OmitNever.ts

@@ -0,0 +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>>;

package/src/typings/PascalCase.ts

@@ -0,0 +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;