deep-case-crafter 1.0.0 → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 gyrgy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.cts

@@ -0,0 +1,231 @@
+/**
+ * Represents the supported string case formats for transformation
+ */
+type StringCase = 'camel' | 'pascal' | 'snake' | 'kebab';
+
+/**
+ * Options for the transform function
+ */
+interface TransformOptions {
+    /**
+     * The target casing format to transform to
+     * @default 'camel'
+     */
+    targetCase?: StringCase;
+    /**
+     * The source casing format to transform from
+     *
+     * When specified:
+     * - Provides precise TypeScript type transformations
+     * - Bypasses runtime case detection (more efficient)
+     * - Ensures consistent results if input has mixed casing
+     *
+     * When omitted:
+     * - Automatic case detection is used at runtime
+     * - TypeScript types will be less precise (string keys)
+     * - Works with mixed case inputs (each key detected separately)
+     *
+     * @example
+     * // With source specified - precise types
+     * const result = transform(data, { targetCase: 'camel', sourceCase: 'snake' });
+     * // result has exact transformed types
+     *
+     * // Without source - flexible runtime behavior
+     * const result = transform(data, { targetCase: 'camel' });
+     * // TypeScript types are more general
+     *
+     * @default undefined (automatic detection)
+     */
+    sourceCase?: StringCase;
+}
+
+/**
+ * Type utility that transforms a snake_case string to camelCase
+ * Example: 'hello_world' -> 'helloWorld'
+ */
+type SnakeToCamel<S extends string> = S extends `${infer P}_${infer C}${infer R}` ? `${P}${Uppercase<C>}${SnakeToCamel<R>}` : S;
+/**
+ * Type utility that transforms a snake_case string to PascalCase
+ * Example: 'hello_world' -> 'HelloWorld'
+ */
+type SnakeWordsToPascal<Parts extends string[]> = Parts extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? `${Capitalize<First>}${SnakeWordsToPascal<Rest>}` : '';
+type SnakeToWords<S extends string> = S extends `${infer P}_${infer R}` ? [P, ...SnakeToWords<R>] : [S];
+type SnakeToPascal<S extends string> = S extends `${infer P}_${infer R}` ? SnakeWordsToPascal<[P, ...SnakeToWords<R>]> : Capitalize<S>;
+/**
+ * Type utility that transforms a snake_case string to kebab-case
+ * Example: 'hello_world' -> 'hello-world'
+ */
+type SnakeToKebab<S extends string> = S extends `${infer P}_${infer R}` ? `${P}-${SnakeToKebab<R>}` : S;
+/**
+ * Type utility that transforms a camelCase string to snake_case
+ * Example: 'helloWorld' -> 'hello_world'
+ */
+type CamelToSnake<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `_${Lowercase<C>}${CamelToSnake<R>}` : `${C}${CamelToSnake<R>}` : S;
+/**
+ * Type utility that transforms a camelCase string to PascalCase
+ * Example: 'helloWorld' -> 'HelloWorld'
+ */
+type CamelToPascal<S extends string> = Capitalize<S>;
+/**
+ * Type utility that transforms a camelCase string to kebab-case
+ * Example: 'helloWorld' -> 'hello-world'
+ */
+type CamelToKebab<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `-${Lowercase<C>}${CamelToKebab<R>}` : `${C}${CamelToKebab<R>}` : S;
+/**
+ * Type utility that transforms a PascalCase string to camelCase
+ * Example: 'HelloWorld' -> 'helloWorld'
+ */
+type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+/**
+ * Type utility that transforms a PascalCase string to snake_case
+ * Example: 'HelloWorld' -> 'hello_world'
+ */
+type PascalToSnake<S extends string> = S extends `${infer F}${infer R}` ? R extends `` ? Lowercase<F> : `${Lowercase<F>}${PascalToSnakeInner<R>}` : S;
+type PascalToSnakeInner<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `_${Lowercase<C>}${PascalToSnakeInner<R>}` : `${C}${PascalToSnakeInner<R>}` : S;
+/**
+ * Type utility that transforms a PascalCase string to kebab-case
+ * Example: 'HelloWorld' -> 'hello-world'
+ */
+type PascalToKebab<S extends string> = S extends `${infer F}${infer R}` ? R extends `` ? Lowercase<F> : `${Lowercase<F>}${PascalToKebabInner<R>}` : S;
+type PascalToKebabInner<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `-${Lowercase<C>}${PascalToKebabInner<R>}` : `${C}${PascalToKebabInner<R>}` : S;
+/**
+ * Type utility that transforms a kebab-case string to camelCase
+ * Example: 'hello-world' -> 'helloWorld'
+ */
+type KebabToCamel<S extends string> = S extends `${infer P}-${infer C}${infer R}` ? `${P}${Uppercase<C>}${KebabToCamel<R>}` : S;
+/**
+ * Type utility that transforms a kebab-case string to PascalCase
+ * Example: 'hello-world' -> 'HelloWorld'
+ */
+type KebabWordsToPascal<Parts extends string[]> = Parts extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? `${Capitalize<First>}${KebabWordsToPascal<Rest>}` : '';
+type KebabToWords<S extends string> = S extends `${infer P}-${infer R}` ? [P, ...KebabToWords<R>] : [S];
+/**
+ * Type utility that transforms a kebab-case string to PascalCase
+ * Example: 'hello-world' -> 'HelloWorld'
+ */
+type KebabToPascal<S extends string> = S extends `${infer P}-${infer R}` ? KebabWordsToPascal<[P, ...KebabToWords<R>]> : Capitalize<S>;
+/**
+ * Type utility that transforms a kebab-case string to snake_case
+ * Example: 'hello-world' -> 'hello_world'
+ */
+type KebabToSnake<S extends string> = S extends `${infer P}-${infer R}` ? `${P}_${KebabToSnake<R>}` : S;
+/**
+ * Utility type to detect preserved keys that shouldn't be transformed.
+ * Preserved keys include those with leading/trailing special characters,
+ * unsupported patterns, or invalid starting/ending characters.
+ */
+type ForbiddenStartChars = '_' | '-' | '$' | '&' | '%' | '#' | '@' | '!' | '*' | '+' | '=' | '~' | '`' | '^' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '\\' | ':' | ';' | '"' | "'" | '<' | '>' | ',' | '.' | '?' | '/';
+type ForbiddenEndChars = '_' | '-' | '$' | '&' | '%' | '#' | '@' | '!' | '*' | '+' | '=' | '~' | '`' | '^' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '\\' | ':' | ';' | '"' | "'" | '<' | '>' | ',' | '.' | '?' | '/' | `${number}`;
+type PreservedKey<K extends string> = K extends `${infer First}${string}` ? First extends ForbiddenStartChars ? true : K extends `${string}${infer Last}` ? Last extends ForbiddenEndChars ? true : K extends `${string}__${string}` | `${string}--${string}` ? true : false : false : false;
+/**
+ * Type utility that selects the correct string transformation based on source and target casing
+ */
+type TransformKey<K extends string, O extends TransformOptions> = PreservedKey<K> extends true ? K : undefined extends O['sourceCase'] ? string : O['sourceCase'] extends 'snake' ? undefined extends O['targetCase'] ? SnakeToCamel<K> : O['targetCase'] extends 'camel' ? SnakeToCamel<K> : O['targetCase'] extends 'pascal' ? SnakeToPascal<K> : O['targetCase'] extends 'kebab' ? SnakeToKebab<K> : K : O['sourceCase'] extends 'camel' ? undefined extends O['targetCase'] ? K : O['targetCase'] extends 'snake' ? CamelToSnake<K> : O['targetCase'] extends 'pascal' ? CamelToPascal<K> : O['targetCase'] extends 'kebab' ? CamelToKebab<K> : K : O['sourceCase'] extends 'pascal' ? undefined extends O['targetCase'] ? PascalToCamel<K> : O['targetCase'] extends 'camel' ? PascalToCamel<K> : O['targetCase'] extends 'snake' ? PascalToSnake<K> : O['targetCase'] extends 'kebab' ? PascalToKebab<K> : K : O['sourceCase'] extends 'kebab' ? undefined extends O['targetCase'] ? KebabToCamel<K> : O['targetCase'] extends 'camel' ? KebabToCamel<K> : O['targetCase'] extends 'pascal' ? KebabToPascal<K> : O['targetCase'] extends 'snake' ? KebabToSnake<K> : K : K;
+/**
+ * Recursive type transformations
+ * These types handle nested structures like arrays, objects, Maps, and Sets
+ */
+type SnakeToCamelRecursive<T> = T extends Array<infer U> ? Array<SnakeToCamelRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? SnakeToCamel<K> : K, SnakeToCamelRecursive<V>> : T extends Set<infer V> ? Set<SnakeToCamelRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'snake';
+        targetCase: 'camel';
+    }>]: SnakeToCamelRecursive<T[K]>;
+} : T;
+type SnakeToPascalRecursive<T> = T extends Array<infer U> ? Array<SnakeToPascalRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? SnakeToPascal<K> : K, SnakeToPascalRecursive<V>> : T extends Set<infer V> ? Set<SnakeToPascalRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'snake';
+        targetCase: 'pascal';
+    }>]: SnakeToPascalRecursive<T[K]>;
+} : T;
+type SnakeToKebabRecursive<T> = T extends Array<infer U> ? Array<SnakeToKebabRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? SnakeToKebab<K> : K, SnakeToKebabRecursive<V>> : T extends Set<infer V> ? Set<SnakeToKebabRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'snake';
+        targetCase: 'kebab';
+    }>]: SnakeToKebabRecursive<T[K]>;
+} : T;
+type CamelToSnakeRecursive<T> = T extends Array<infer U> ? Array<CamelToSnakeRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? CamelToSnake<K> : K, CamelToSnakeRecursive<V>> : T extends Set<infer V> ? Set<CamelToSnakeRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'camel';
+        targetCase: 'snake';
+    }>]: CamelToSnakeRecursive<T[K]>;
+} : T;
+type CamelToPascalRecursive<T> = T extends Array<infer U> ? Array<CamelToPascalRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? CamelToPascal<K> : K, CamelToPascalRecursive<V>> : T extends Set<infer V> ? Set<CamelToPascalRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'camel';
+        targetCase: 'pascal';
+    }>]: CamelToPascalRecursive<T[K]>;
+} : T;
+type CamelToKebabRecursive<T> = T extends Array<infer U> ? Array<CamelToKebabRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? CamelToKebab<K> : K, CamelToKebabRecursive<V>> : T extends Set<infer V> ? Set<CamelToKebabRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'camel';
+        targetCase: 'kebab';
+    }>]: CamelToKebabRecursive<T[K]>;
+} : T;
+type PascalToCamelRecursive<T> = T extends Array<infer U> ? Array<PascalToCamelRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? PascalToCamel<K> : K, PascalToCamelRecursive<V>> : T extends Set<infer V> ? Set<PascalToCamelRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'pascal';
+        targetCase: 'camel';
+    }>]: PascalToCamelRecursive<T[K]>;
+} : T;
+type PascalToSnakeRecursive<T> = T extends Array<infer U> ? Array<PascalToSnakeRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? PascalToSnake<K> : K, PascalToSnakeRecursive<V>> : T extends Set<infer V> ? Set<PascalToSnakeRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'pascal';
+        targetCase: 'snake';
+    }>]: PascalToSnakeRecursive<T[K]>;
+} : T;
+type PascalToKebabRecursive<T> = T extends Array<infer U> ? Array<PascalToKebabRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? PascalToKebab<K> : K, PascalToKebabRecursive<V>> : T extends Set<infer V> ? Set<PascalToKebabRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'pascal';
+        targetCase: 'kebab';
+    }>]: PascalToKebabRecursive<T[K]>;
+} : T;
+type KebabToCamelRecursive<T> = T extends Array<infer U> ? Array<KebabToCamelRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? KebabToCamel<K> : K, KebabToCamelRecursive<V>> : T extends Set<infer V> ? Set<KebabToCamelRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'kebab';
+        targetCase: 'camel';
+    }>]: KebabToCamelRecursive<T[K]>;
+} : T;
+type KebabToPascalRecursive<T> = T extends Array<infer U> ? Array<KebabToPascalRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? KebabToPascal<K> : K, KebabToPascalRecursive<V>> : T extends Set<infer V> ? Set<KebabToPascalRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'kebab';
+        targetCase: 'pascal';
+    }>]: KebabToPascalRecursive<T[K]>;
+} : T;
+type KebabToSnakeRecursive<T> = T extends Array<infer U> ? Array<KebabToSnakeRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? KebabToSnake<K> : K, KebabToSnakeRecursive<V>> : T extends Set<infer V> ? Set<KebabToSnakeRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'kebab';
+        targetCase: 'snake';
+    }>]: KebabToSnakeRecursive<T[K]>;
+} : T;
+/**
+ * Generic recursive transformation type
+ * Allows dynamically selecting the transformation based on source and target cases
+ */
+type TransformRecursive<T, FromCase extends StringCase, ToCase extends StringCase> = FromCase extends 'snake' ? ToCase extends 'camel' ? SnakeToCamelRecursive<T> : ToCase extends 'pascal' ? SnakeToPascalRecursive<T> : ToCase extends 'kebab' ? SnakeToKebabRecursive<T> : T : FromCase extends 'camel' ? ToCase extends 'snake' ? CamelToSnakeRecursive<T> : ToCase extends 'pascal' ? CamelToPascalRecursive<T> : ToCase extends 'kebab' ? CamelToKebabRecursive<T> : T : FromCase extends 'pascal' ? ToCase extends 'snake' ? PascalToSnakeRecursive<T> : ToCase extends 'camel' ? PascalToCamelRecursive<T> : ToCase extends 'kebab' ? PascalToKebabRecursive<T> : T : FromCase extends 'kebab' ? ToCase extends 'snake' ? KebabToSnakeRecursive<T> : ToCase extends 'camel' ? KebabToCamelRecursive<T> : ToCase extends 'pascal' ? KebabToPascalRecursive<T> : T : T;
+
+declare function transform<T, From extends StringCase, To extends StringCase>(data: T, options: TransformOptions & {
+    depth?: number;
+    sourceCase: From;
+    targetCase: To;
+}): TransformRecursive<T, From, To>;
+/**
+ * Transform data to a specified output type.
+ *
+ * Note: When using this overload, type safety is not enforced between the input, options, and output type.
+ * The 'sourceCase' option is intentionally omitted, as it is not used for type inference here.
+ */
+declare function transform<T, K>(data: T, options?: Omit<TransformOptions, 'sourceCase'> & {
+    depth?: number;
+}): K;
+declare function transform<T>(data: T, options?: TransformOptions & {
+    depth?: number;
+}): unknown;
+
+export { transform };
+export type { StringCase, TransformOptions };

package/dist/index.d.mts

@@ -0,0 +1,231 @@
+/**
+ * Represents the supported string case formats for transformation
+ */
+type StringCase = 'camel' | 'pascal' | 'snake' | 'kebab';
+
+/**
+ * Options for the transform function
+ */
+interface TransformOptions {
+    /**
+     * The target casing format to transform to
+     * @default 'camel'
+     */
+    targetCase?: StringCase;
+    /**
+     * The source casing format to transform from
+     *
+     * When specified:
+     * - Provides precise TypeScript type transformations
+     * - Bypasses runtime case detection (more efficient)
+     * - Ensures consistent results if input has mixed casing
+     *
+     * When omitted:
+     * - Automatic case detection is used at runtime
+     * - TypeScript types will be less precise (string keys)
+     * - Works with mixed case inputs (each key detected separately)
+     *
+     * @example
+     * // With source specified - precise types
+     * const result = transform(data, { targetCase: 'camel', sourceCase: 'snake' });
+     * // result has exact transformed types
+     *
+     * // Without source - flexible runtime behavior
+     * const result = transform(data, { targetCase: 'camel' });
+     * // TypeScript types are more general
+     *
+     * @default undefined (automatic detection)
+     */
+    sourceCase?: StringCase;
+}
+
+/**
+ * Type utility that transforms a snake_case string to camelCase
+ * Example: 'hello_world' -> 'helloWorld'
+ */
+type SnakeToCamel<S extends string> = S extends `${infer P}_${infer C}${infer R}` ? `${P}${Uppercase<C>}${SnakeToCamel<R>}` : S;
+/**
+ * Type utility that transforms a snake_case string to PascalCase
+ * Example: 'hello_world' -> 'HelloWorld'
+ */
+type SnakeWordsToPascal<Parts extends string[]> = Parts extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? `${Capitalize<First>}${SnakeWordsToPascal<Rest>}` : '';
+type SnakeToWords<S extends string> = S extends `${infer P}_${infer R}` ? [P, ...SnakeToWords<R>] : [S];
+type SnakeToPascal<S extends string> = S extends `${infer P}_${infer R}` ? SnakeWordsToPascal<[P, ...SnakeToWords<R>]> : Capitalize<S>;
+/**
+ * Type utility that transforms a snake_case string to kebab-case
+ * Example: 'hello_world' -> 'hello-world'
+ */
+type SnakeToKebab<S extends string> = S extends `${infer P}_${infer R}` ? `${P}-${SnakeToKebab<R>}` : S;
+/**
+ * Type utility that transforms a camelCase string to snake_case
+ * Example: 'helloWorld' -> 'hello_world'
+ */
+type CamelToSnake<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `_${Lowercase<C>}${CamelToSnake<R>}` : `${C}${CamelToSnake<R>}` : S;
+/**
+ * Type utility that transforms a camelCase string to PascalCase
+ * Example: 'helloWorld' -> 'HelloWorld'
+ */
+type CamelToPascal<S extends string> = Capitalize<S>;
+/**
+ * Type utility that transforms a camelCase string to kebab-case
+ * Example: 'helloWorld' -> 'hello-world'
+ */
+type CamelToKebab<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `-${Lowercase<C>}${CamelToKebab<R>}` : `${C}${CamelToKebab<R>}` : S;
+/**
+ * Type utility that transforms a PascalCase string to camelCase
+ * Example: 'HelloWorld' -> 'helloWorld'
+ */
+type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+/**
+ * Type utility that transforms a PascalCase string to snake_case
+ * Example: 'HelloWorld' -> 'hello_world'
+ */
+type PascalToSnake<S extends string> = S extends `${infer F}${infer R}` ? R extends `` ? Lowercase<F> : `${Lowercase<F>}${PascalToSnakeInner<R>}` : S;
+type PascalToSnakeInner<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `_${Lowercase<C>}${PascalToSnakeInner<R>}` : `${C}${PascalToSnakeInner<R>}` : S;
+/**
+ * Type utility that transforms a PascalCase string to kebab-case
+ * Example: 'HelloWorld' -> 'hello-world'
+ */
+type PascalToKebab<S extends string> = S extends `${infer F}${infer R}` ? R extends `` ? Lowercase<F> : `${Lowercase<F>}${PascalToKebabInner<R>}` : S;
+type PascalToKebabInner<S extends string> = S extends `${infer C}${infer R}` ? C extends Uppercase<C> ? `-${Lowercase<C>}${PascalToKebabInner<R>}` : `${C}${PascalToKebabInner<R>}` : S;
+/**
+ * Type utility that transforms a kebab-case string to camelCase
+ * Example: 'hello-world' -> 'helloWorld'
+ */
+type KebabToCamel<S extends string> = S extends `${infer P}-${infer C}${infer R}` ? `${P}${Uppercase<C>}${KebabToCamel<R>}` : S;
+/**
+ * Type utility that transforms a kebab-case string to PascalCase
+ * Example: 'hello-world' -> 'HelloWorld'
+ */
+type KebabWordsToPascal<Parts extends string[]> = Parts extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? `${Capitalize<First>}${KebabWordsToPascal<Rest>}` : '';
+type KebabToWords<S extends string> = S extends `${infer P}-${infer R}` ? [P, ...KebabToWords<R>] : [S];
+/**
+ * Type utility that transforms a kebab-case string to PascalCase
+ * Example: 'hello-world' -> 'HelloWorld'
+ */
+type KebabToPascal<S extends string> = S extends `${infer P}-${infer R}` ? KebabWordsToPascal<[P, ...KebabToWords<R>]> : Capitalize<S>;
+/**
+ * Type utility that transforms a kebab-case string to snake_case
+ * Example: 'hello-world' -> 'hello_world'
+ */
+type KebabToSnake<S extends string> = S extends `${infer P}-${infer R}` ? `${P}_${KebabToSnake<R>}` : S;
+/**
+ * Utility type to detect preserved keys that shouldn't be transformed.
+ * Preserved keys include those with leading/trailing special characters,
+ * unsupported patterns, or invalid starting/ending characters.
+ */
+type ForbiddenStartChars = '_' | '-' | '$' | '&' | '%' | '#' | '@' | '!' | '*' | '+' | '=' | '~' | '`' | '^' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '\\' | ':' | ';' | '"' | "'" | '<' | '>' | ',' | '.' | '?' | '/';
+type ForbiddenEndChars = '_' | '-' | '$' | '&' | '%' | '#' | '@' | '!' | '*' | '+' | '=' | '~' | '`' | '^' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '\\' | ':' | ';' | '"' | "'" | '<' | '>' | ',' | '.' | '?' | '/' | `${number}`;
+type PreservedKey<K extends string> = K extends `${infer First}${string}` ? First extends ForbiddenStartChars ? true : K extends `${string}${infer Last}` ? Last extends ForbiddenEndChars ? true : K extends `${string}__${string}` | `${string}--${string}` ? true : false : false : false;
+/**
+ * Type utility that selects the correct string transformation based on source and target casing
+ */
+type TransformKey<K extends string, O extends TransformOptions> = PreservedKey<K> extends true ? K : undefined extends O['sourceCase'] ? string : O['sourceCase'] extends 'snake' ? undefined extends O['targetCase'] ? SnakeToCamel<K> : O['targetCase'] extends 'camel' ? SnakeToCamel<K> : O['targetCase'] extends 'pascal' ? SnakeToPascal<K> : O['targetCase'] extends 'kebab' ? SnakeToKebab<K> : K : O['sourceCase'] extends 'camel' ? undefined extends O['targetCase'] ? K : O['targetCase'] extends 'snake' ? CamelToSnake<K> : O['targetCase'] extends 'pascal' ? CamelToPascal<K> : O['targetCase'] extends 'kebab' ? CamelToKebab<K> : K : O['sourceCase'] extends 'pascal' ? undefined extends O['targetCase'] ? PascalToCamel<K> : O['targetCase'] extends 'camel' ? PascalToCamel<K> : O['targetCase'] extends 'snake' ? PascalToSnake<K> : O['targetCase'] extends 'kebab' ? PascalToKebab<K> : K : O['sourceCase'] extends 'kebab' ? undefined extends O['targetCase'] ? KebabToCamel<K> : O['targetCase'] extends 'camel' ? KebabToCamel<K> : O['targetCase'] extends 'pascal' ? KebabToPascal<K> : O['targetCase'] extends 'snake' ? KebabToSnake<K> : K : K;
+/**
+ * Recursive type transformations
+ * These types handle nested structures like arrays, objects, Maps, and Sets
+ */
+type SnakeToCamelRecursive<T> = T extends Array<infer U> ? Array<SnakeToCamelRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? SnakeToCamel<K> : K, SnakeToCamelRecursive<V>> : T extends Set<infer V> ? Set<SnakeToCamelRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'snake';
+        targetCase: 'camel';
+    }>]: SnakeToCamelRecursive<T[K]>;
+} : T;
+type SnakeToPascalRecursive<T> = T extends Array<infer U> ? Array<SnakeToPascalRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? SnakeToPascal<K> : K, SnakeToPascalRecursive<V>> : T extends Set<infer V> ? Set<SnakeToPascalRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'snake';
+        targetCase: 'pascal';
+    }>]: SnakeToPascalRecursive<T[K]>;
+} : T;
+type SnakeToKebabRecursive<T> = T extends Array<infer U> ? Array<SnakeToKebabRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? SnakeToKebab<K> : K, SnakeToKebabRecursive<V>> : T extends Set<infer V> ? Set<SnakeToKebabRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'snake';
+        targetCase: 'kebab';
+    }>]: SnakeToKebabRecursive<T[K]>;
+} : T;
+type CamelToSnakeRecursive<T> = T extends Array<infer U> ? Array<CamelToSnakeRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? CamelToSnake<K> : K, CamelToSnakeRecursive<V>> : T extends Set<infer V> ? Set<CamelToSnakeRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'camel';
+        targetCase: 'snake';
+    }>]: CamelToSnakeRecursive<T[K]>;
+} : T;
+type CamelToPascalRecursive<T> = T extends Array<infer U> ? Array<CamelToPascalRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? CamelToPascal<K> : K, CamelToPascalRecursive<V>> : T extends Set<infer V> ? Set<CamelToPascalRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'camel';
+        targetCase: 'pascal';
+    }>]: CamelToPascalRecursive<T[K]>;
+} : T;
+type CamelToKebabRecursive<T> = T extends Array<infer U> ? Array<CamelToKebabRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? CamelToKebab<K> : K, CamelToKebabRecursive<V>> : T extends Set<infer V> ? Set<CamelToKebabRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'camel';
+        targetCase: 'kebab';
+    }>]: CamelToKebabRecursive<T[K]>;
+} : T;
+type PascalToCamelRecursive<T> = T extends Array<infer U> ? Array<PascalToCamelRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? PascalToCamel<K> : K, PascalToCamelRecursive<V>> : T extends Set<infer V> ? Set<PascalToCamelRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'pascal';
+        targetCase: 'camel';
+    }>]: PascalToCamelRecursive<T[K]>;
+} : T;
+type PascalToSnakeRecursive<T> = T extends Array<infer U> ? Array<PascalToSnakeRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? PascalToSnake<K> : K, PascalToSnakeRecursive<V>> : T extends Set<infer V> ? Set<PascalToSnakeRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'pascal';
+        targetCase: 'snake';
+    }>]: PascalToSnakeRecursive<T[K]>;
+} : T;
+type PascalToKebabRecursive<T> = T extends Array<infer U> ? Array<PascalToKebabRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? PascalToKebab<K> : K, PascalToKebabRecursive<V>> : T extends Set<infer V> ? Set<PascalToKebabRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'pascal';
+        targetCase: 'kebab';
+    }>]: PascalToKebabRecursive<T[K]>;
+} : T;
+type KebabToCamelRecursive<T> = T extends Array<infer U> ? Array<KebabToCamelRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? KebabToCamel<K> : K, KebabToCamelRecursive<V>> : T extends Set<infer V> ? Set<KebabToCamelRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'kebab';
+        targetCase: 'camel';
+    }>]: KebabToCamelRecursive<T[K]>;
+} : T;
+type KebabToPascalRecursive<T> = T extends Array<infer U> ? Array<KebabToPascalRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? KebabToPascal<K> : K, KebabToPascalRecursive<V>> : T extends Set<infer V> ? Set<KebabToPascalRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'kebab';
+        targetCase: 'pascal';
+    }>]: KebabToPascalRecursive<T[K]>;
+} : T;
+type KebabToSnakeRecursive<T> = T extends Array<infer U> ? Array<KebabToSnakeRecursive<U>> : T extends Map<infer K, infer V> ? Map<K extends string ? KebabToSnake<K> : K, KebabToSnakeRecursive<V>> : T extends Set<infer V> ? Set<KebabToSnakeRecursive<V>> : T extends object ? {
+    [K in keyof T as TransformKey<K & string, {
+        sourceCase: 'kebab';
+        targetCase: 'snake';
+    }>]: KebabToSnakeRecursive<T[K]>;
+} : T;
+/**
+ * Generic recursive transformation type
+ * Allows dynamically selecting the transformation based on source and target cases
+ */
+type TransformRecursive<T, FromCase extends StringCase, ToCase extends StringCase> = FromCase extends 'snake' ? ToCase extends 'camel' ? SnakeToCamelRecursive<T> : ToCase extends 'pascal' ? SnakeToPascalRecursive<T> : ToCase extends 'kebab' ? SnakeToKebabRecursive<T> : T : FromCase extends 'camel' ? ToCase extends 'snake' ? CamelToSnakeRecursive<T> : ToCase extends 'pascal' ? CamelToPascalRecursive<T> : ToCase extends 'kebab' ? CamelToKebabRecursive<T> : T : FromCase extends 'pascal' ? ToCase extends 'snake' ? PascalToSnakeRecursive<T> : ToCase extends 'camel' ? PascalToCamelRecursive<T> : ToCase extends 'kebab' ? PascalToKebabRecursive<T> : T : FromCase extends 'kebab' ? ToCase extends 'snake' ? KebabToSnakeRecursive<T> : ToCase extends 'camel' ? KebabToCamelRecursive<T> : ToCase extends 'pascal' ? KebabToPascalRecursive<T> : T : T;
+
+declare function transform<T, From extends StringCase, To extends StringCase>(data: T, options: TransformOptions & {
+    depth?: number;
+    sourceCase: From;
+    targetCase: To;
+}): TransformRecursive<T, From, To>;
+/**
+ * Transform data to a specified output type.
+ *
+ * Note: When using this overload, type safety is not enforced between the input, options, and output type.
+ * The 'sourceCase' option is intentionally omitted, as it is not used for type inference here.
+ */
+declare function transform<T, K>(data: T, options?: Omit<TransformOptions, 'sourceCase'> & {
+    depth?: number;
+}): K;
+declare function transform<T>(data: T, options?: TransformOptions & {
+    depth?: number;
+}): unknown;
+
+export { transform };
+export type { StringCase, TransformOptions };