es-toolkit 1.50.0-dev.2053 → 1.50.0-dev.2055

package/dist/_internal/NonPlainObject.d.mts

@@ -0,0 +1,8 @@
+//#region src/_internal/NonPlainObject.d.ts
+/**
+ * Built-in object types that key-conversion types like `ToCamelCaseKeys`
+ * leave unchanged instead of mapping over their properties.
+ */
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+//#endregion
+export { NonPlainObject };

package/dist/_internal/NonPlainObject.d.ts

@@ -0,0 +1,8 @@
+//#region src/_internal/NonPlainObject.d.ts
+/**
+ * Built-in object types that key-conversion types like `ToCamelCaseKeys`
+ * leave unchanged instead of mapping over their properties.
+ */
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+//#endregion
+export { NonPlainObject };

package/dist/object/toCamelCaseKeys.d.mts

@@ -1,10 +1,6 @@
+import { ToCamelCaseKeys } from "../types/ToCamelCaseKeys.mjs";
+
 //#region src/object/toCamelCaseKeys.d.ts
-type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
-type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
-/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
-type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to camelCase.
  *

package/dist/object/toCamelCaseKeys.d.ts

@@ -1,10 +1,6 @@
+import { ToCamelCaseKeys } from "../types/ToCamelCaseKeys.js";
+
 //#region src/object/toCamelCaseKeys.d.ts
-type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
-type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
-/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
-type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to camelCase.
  *

package/dist/object/toConstantCaseKeys.d.mts

@@ -1,7 +1,6 @@
+import { ToConstantCaseKeys } from "../types/ToConstantCaseKeys.mjs";
+
 //#region src/object/toConstantCaseKeys.d.ts
-type ConstantCase<S extends string> = S extends Lowercase<S> ? Uppercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uppercase<P1>}${ConstantCase<P2>}` : `${Uppercase<P1>}_${ConstantCase<Uncapitalize<P2>>}` : Uppercase<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToConstantCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToConstantCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as ConstantCase<string & K>]: ToConstantCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
  *

package/dist/object/toConstantCaseKeys.d.ts

@@ -1,7 +1,6 @@
+import { ToConstantCaseKeys } from "../types/ToConstantCaseKeys.js";
+
 //#region src/object/toConstantCaseKeys.d.ts
-type ConstantCase<S extends string> = S extends Lowercase<S> ? Uppercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uppercase<P1>}${ConstantCase<P2>}` : `${Uppercase<P1>}_${ConstantCase<Uncapitalize<P2>>}` : Uppercase<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToConstantCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToConstantCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as ConstantCase<string & K>]: ToConstantCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
  *

package/dist/object/toKebabCaseKeys.d.mts

@@ -1,9 +1,6 @@
+import { ToKebabCaseKeys } from "../types/ToKebabCaseKeys.mjs";
+
 //#region src/object/toKebabCaseKeys.d.ts
-type SnakeToKebab<S extends string> = S extends `${infer P1}_${infer P2}` ? Lowercase<`${P1}-${SnakeToKebab<P2>}`> : Lowercase<S>;
-type CamelToKebab<S extends string> = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${CamelToKebab<P2>}` : `${Lowercase<P1>}-${CamelToKebab<Uncapitalize<P2>>}` : S;
-type KebabCase<S extends string> = S extends `${string}_${string}` ? SnakeToKebab<S> : S extends Uppercase<S> ? Lowercase<S> : CamelToKebab<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToKebabCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToKebabCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as KebabCase<string & K>]: ToKebabCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to kebab-case.
  *

package/dist/object/toKebabCaseKeys.d.ts

@@ -1,9 +1,6 @@
+import { ToKebabCaseKeys } from "../types/ToKebabCaseKeys.js";
+
 //#region src/object/toKebabCaseKeys.d.ts
-type SnakeToKebab<S extends string> = S extends `${infer P1}_${infer P2}` ? Lowercase<`${P1}-${SnakeToKebab<P2>}`> : Lowercase<S>;
-type CamelToKebab<S extends string> = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${CamelToKebab<P2>}` : `${Lowercase<P1>}-${CamelToKebab<Uncapitalize<P2>>}` : S;
-type KebabCase<S extends string> = S extends `${string}_${string}` ? SnakeToKebab<S> : S extends Uppercase<S> ? Lowercase<S> : CamelToKebab<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToKebabCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToKebabCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as KebabCase<string & K>]: ToKebabCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to kebab-case.
  *

package/dist/object/toPascalCaseKeys.d.mts

@@ -1,10 +1,6 @@
+import { ToPascalCaseKeys } from "../types/ToPascalCaseKeys.mjs";
+
 //#region src/object/toPascalCaseKeys.d.ts
-type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}` ? `${Capitalize<Lowercase<H>>}${Capitalize<SnakeToPascal<T>>}` : Capitalize<Lowercase<S>>;
-type CamelToPascal<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
-/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase and capitalize the entire string; otherwise, just uppercase the first letter (including camelCase → PascalCase). */
-type AnyToPascal<S extends string> = S extends `${string}_${string}` ? SnakeToPascal<S> : S extends Uppercase<S> ? Capitalize<Lowercase<S>> : CamelToPascal<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToPascalCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToPascalCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToPascal<Extract<K, string>>]: ToPascalCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to PascalCase.
  *

package/dist/object/toPascalCaseKeys.d.ts

@@ -1,10 +1,6 @@
+import { ToPascalCaseKeys } from "../types/ToPascalCaseKeys.js";
+
 //#region src/object/toPascalCaseKeys.d.ts
-type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}` ? `${Capitalize<Lowercase<H>>}${Capitalize<SnakeToPascal<T>>}` : Capitalize<Lowercase<S>>;
-type CamelToPascal<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
-/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase and capitalize the entire string; otherwise, just uppercase the first letter (including camelCase → PascalCase). */
-type AnyToPascal<S extends string> = S extends `${string}_${string}` ? SnakeToPascal<S> : S extends Uppercase<S> ? Capitalize<Lowercase<S>> : CamelToPascal<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToPascalCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToPascalCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToPascal<Extract<K, string>>]: ToPascalCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to PascalCase.
  *

package/dist/object/toSnakeCaseKeys.d.mts

@@ -1,7 +1,6 @@
+import { ToSnakeCaseKeys } from "../types/ToSnakeCaseKeys.mjs";
+
 //#region src/object/toSnakeCaseKeys.d.ts
-type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to snake_case.
  *

package/dist/object/toSnakeCaseKeys.d.ts

@@ -1,7 +1,6 @@
+import { ToSnakeCaseKeys } from "../types/ToSnakeCaseKeys.js";
+
 //#region src/object/toSnakeCaseKeys.d.ts
-type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to snake_case.
  *

package/dist/types/ToCamelCaseKeys.d.mts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToCamelCaseKeys.d.ts
+type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
+type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
+type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
+/**
+ * Converts the keys of `T` to camelCase recursively.
+ *
+ * This is the return type of the `toCamelCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { user_id: number; first_name: string };
+ * type Converted = ToCamelCaseKeys<Response>;
+ * // => { userId: number; firstName: string }
+ */
+type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
+//#endregion
+export { ToCamelCaseKeys };

package/dist/types/ToCamelCaseKeys.d.ts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToCamelCaseKeys.d.ts
+type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
+type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
+type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
+/**
+ * Converts the keys of `T` to camelCase recursively.
+ *
+ * This is the return type of the `toCamelCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { user_id: number; first_name: string };
+ * type Converted = ToCamelCaseKeys<Response>;
+ * // => { userId: number; firstName: string }
+ */
+type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
+//#endregion
+export { ToCamelCaseKeys };

package/dist/types/ToConstantCaseKeys.d.mts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToConstantCaseKeys.d.ts
+type ConstantCase<S extends string> = S extends Lowercase<S> ? Uppercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uppercase<P1>}${ConstantCase<P2>}` : `${Uppercase<P1>}_${ConstantCase<Uncapitalize<P2>>}` : Uppercase<S>;
+/**
+ * Converts the keys of `T` to CONSTANT_CASE recursively.
+ *
+ * This is the return type of the `toConstantCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToConstantCaseKeys<Response>;
+ * // => { USER_ID: number; FIRST_NAME: string }
+ */
+type ToConstantCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToConstantCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as ConstantCase<string & K>]: ToConstantCaseKeys<T[K]> } : T;
+//#endregion
+export { ToConstantCaseKeys };

package/dist/types/ToConstantCaseKeys.d.ts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToConstantCaseKeys.d.ts
+type ConstantCase<S extends string> = S extends Lowercase<S> ? Uppercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uppercase<P1>}${ConstantCase<P2>}` : `${Uppercase<P1>}_${ConstantCase<Uncapitalize<P2>>}` : Uppercase<S>;
+/**
+ * Converts the keys of `T` to CONSTANT_CASE recursively.
+ *
+ * This is the return type of the `toConstantCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToConstantCaseKeys<Response>;
+ * // => { USER_ID: number; FIRST_NAME: string }
+ */
+type ToConstantCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToConstantCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as ConstantCase<string & K>]: ToConstantCaseKeys<T[K]> } : T;
+//#endregion
+export { ToConstantCaseKeys };

package/dist/types/ToKebabCaseKeys.d.mts

@@ -0,0 +1,23 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToKebabCaseKeys.d.ts
+type SnakeToKebab<S extends string> = S extends `${infer P1}_${infer P2}` ? Lowercase<`${P1}-${SnakeToKebab<P2>}`> : Lowercase<S>;
+type CamelToKebab<S extends string> = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${CamelToKebab<P2>}` : `${Lowercase<P1>}-${CamelToKebab<Uncapitalize<P2>>}` : S;
+type KebabCase<S extends string> = S extends `${string}_${string}` ? SnakeToKebab<S> : S extends Uppercase<S> ? Lowercase<S> : CamelToKebab<S>;
+/**
+ * Converts the keys of `T` to kebab-case recursively.
+ *
+ * This is the return type of the `toKebabCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToKebabCaseKeys<Response>;
+ * // => { 'user-id': number; 'first-name': string }
+ */
+type ToKebabCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToKebabCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as KebabCase<string & K>]: ToKebabCaseKeys<T[K]> } : T;
+//#endregion
+export { ToKebabCaseKeys };

package/dist/types/ToKebabCaseKeys.d.ts

@@ -0,0 +1,23 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToKebabCaseKeys.d.ts
+type SnakeToKebab<S extends string> = S extends `${infer P1}_${infer P2}` ? Lowercase<`${P1}-${SnakeToKebab<P2>}`> : Lowercase<S>;
+type CamelToKebab<S extends string> = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${CamelToKebab<P2>}` : `${Lowercase<P1>}-${CamelToKebab<Uncapitalize<P2>>}` : S;
+type KebabCase<S extends string> = S extends `${string}_${string}` ? SnakeToKebab<S> : S extends Uppercase<S> ? Lowercase<S> : CamelToKebab<S>;
+/**
+ * Converts the keys of `T` to kebab-case recursively.
+ *
+ * This is the return type of the `toKebabCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToKebabCaseKeys<Response>;
+ * // => { 'user-id': number; 'first-name': string }
+ */
+type ToKebabCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToKebabCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as KebabCase<string & K>]: ToKebabCaseKeys<T[K]> } : T;
+//#endregion
+export { ToKebabCaseKeys };

package/dist/types/ToPascalCaseKeys.d.mts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToPascalCaseKeys.d.ts
+type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}` ? `${Capitalize<Lowercase<H>>}${Capitalize<SnakeToPascal<T>>}` : Capitalize<Lowercase<S>>;
+type CamelToPascal<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase and capitalize the entire string; otherwise, just uppercase the first letter (including camelCase → PascalCase). */
+type AnyToPascal<S extends string> = S extends `${string}_${string}` ? SnakeToPascal<S> : S extends Uppercase<S> ? Capitalize<Lowercase<S>> : CamelToPascal<S>;
+/**
+ * Converts the keys of `T` to PascalCase recursively.
+ *
+ * This is the return type of the `toPascalCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToPascalCaseKeys<Response>;
+ * // => { UserId: number; FirstName: string }
+ */
+type ToPascalCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToPascalCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToPascal<Extract<K, string>>]: ToPascalCaseKeys<T[K]> } : T;
+//#endregion
+export { ToPascalCaseKeys };

package/dist/types/ToPascalCaseKeys.d.ts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToPascalCaseKeys.d.ts
+type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}` ? `${Capitalize<Lowercase<H>>}${Capitalize<SnakeToPascal<T>>}` : Capitalize<Lowercase<S>>;
+type CamelToPascal<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase and capitalize the entire string; otherwise, just uppercase the first letter (including camelCase → PascalCase). */
+type AnyToPascal<S extends string> = S extends `${string}_${string}` ? SnakeToPascal<S> : S extends Uppercase<S> ? Capitalize<Lowercase<S>> : CamelToPascal<S>;
+/**
+ * Converts the keys of `T` to PascalCase recursively.
+ *
+ * This is the return type of the `toPascalCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToPascalCaseKeys<Response>;
+ * // => { UserId: number; FirstName: string }
+ */
+type ToPascalCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToPascalCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToPascal<Extract<K, string>>]: ToPascalCaseKeys<T[K]> } : T;
+//#endregion
+export { ToPascalCaseKeys };

package/dist/types/ToSnakeCaseKeys.d.mts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToSnakeCaseKeys.d.ts
+type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
+/**
+ * Converts the keys of `T` to snake_case recursively.
+ *
+ * This is the return type of the `toSnakeCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Request = { userId: number; firstName: string };
+ * type Converted = ToSnakeCaseKeys<Request>;
+ * // => { user_id: number; first_name: string }
+ */
+type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
+//#endregion
+export { ToSnakeCaseKeys };

package/dist/types/ToSnakeCaseKeys.d.ts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToSnakeCaseKeys.d.ts
+type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
+/**
+ * Converts the keys of `T` to snake_case recursively.
+ *
+ * This is the return type of the `toSnakeCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Request = { userId: number; firstName: string };
+ * type Converted = ToSnakeCaseKeys<Request>;
+ * // => { user_id: number; first_name: string }
+ */
+type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
+//#endregion
+export { ToSnakeCaseKeys };

package/dist/types/index.d.mts

@@ -1,7 +1,12 @@
+import { ToCamelCaseKeys } from "./ToCamelCaseKeys.mjs";
+import { ToConstantCaseKeys } from "./ToConstantCaseKeys.mjs";
+import { ToKebabCaseKeys } from "./ToKebabCaseKeys.mjs";
+import { ToPascalCaseKeys } from "./ToPascalCaseKeys.mjs";
+import { ToSnakeCaseKeys } from "./ToSnakeCaseKeys.mjs";
 import { DeepPartial } from "./DeepPartial.mjs";
 import { DeepReadonly } from "./DeepReadonly.mjs";
 import { NonEmptyArray } from "./NonEmptyArray.mjs";
 import { Simplify } from "./Simplify.mjs";
 import { ValueOf } from "./ValueOf.mjs";
 import { Writable } from "./Writable.mjs";
-export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ValueOf, type Writable };
+export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ToCamelCaseKeys, type ToConstantCaseKeys, type ToKebabCaseKeys, type ToPascalCaseKeys, type ToSnakeCaseKeys, type ValueOf, type Writable };

package/dist/types/index.d.ts

@@ -1,7 +1,12 @@
+import { ToCamelCaseKeys } from "./ToCamelCaseKeys.js";
+import { ToConstantCaseKeys } from "./ToConstantCaseKeys.js";
+import { ToKebabCaseKeys } from "./ToKebabCaseKeys.js";
+import { ToPascalCaseKeys } from "./ToPascalCaseKeys.js";
+import { ToSnakeCaseKeys } from "./ToSnakeCaseKeys.js";
 import { DeepPartial } from "./DeepPartial.js";
 import { DeepReadonly } from "./DeepReadonly.js";
 import { NonEmptyArray } from "./NonEmptyArray.js";
 import { Simplify } from "./Simplify.js";
 import { ValueOf } from "./ValueOf.js";
 import { Writable } from "./Writable.js";
-export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ValueOf, type Writable };
+export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ToCamelCaseKeys, type ToConstantCaseKeys, type ToKebabCaseKeys, type ToPascalCaseKeys, type ToSnakeCaseKeys, type ValueOf, type Writable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit",
-  "version": "1.50.0-dev.2053+ea692b9f",
+  "version": "1.50.0-dev.2055+658bc937",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
   "homepage": "https://es-toolkit.dev",
   "bugs": "https://github.com/toss/es-toolkit/issues",