If you come across an object that contains nested arrays, it's a good idea to add an extra layer of wrapping. This approach is inspired by the solution provided by Max Eisenhardt.

We can validate if the data is in Array format, and if it is, we can extract the object type within the current functionality.

Failing to do so will result in array functions being flagged as non-callable.

 type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}`
    ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}`
    : Lowercase<S>

  type ObjectToCamel<T> = {
    [K in keyof T as CamelCase<string &K>]: T[K] extends Record<string, any> ? KeysToCamelCase<T[K]> : T[K]
  }

  type KeysToCamelCase<T> = {
    [K in keyof T as CamelCase<string &K>]: T[K] extends Array<any> ? KeysToCamelCase<T[K][number]>[] : ObjectToCamel<T[K]>
  }  

For those seeking the opposite transformation, here is an alternative solution to Max Eisenhardt's response:

type CapitalizedLetters = (
  'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' |
  'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' |
  'Y' | 'Z' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
)

type CamelCaseSeq<S extends string> = S extends `${infer P1}${infer P2}`
  ? P1 extends CapitalizedLetters
    ? `_${Lowercase<P1>}${CamelCaseSeq<P2>}`
    : `${P1}${CamelCaseSeq<P2>}`
  : Lowercase<S>;

export type CamelCase<S extends string> = S extends `${infer P1}${infer P2}`
  ? `${Lowercase<P1>}${CamelCaseSeq<P2>}`
  : Lowercase<S>;

type ObjectToCamelCase<T> = {
  [K in keyof T as CamelCase<string &K>]: T[K] extends Record<string, any>
    ? KeysToCamelCase<T[K]>
    : T[K];
};

export type KeysToCamelCase<T> = {
  [K in keyof T as CamelCase<string &K>]: T[K] extends Array<any>
    ? KeysToCamelCase<T[K][number]>[]
    : ObjectToCamelCase<T[K]>;
};

After reviewing the responses from Max Eisenhardt and Hespen, I propose a solution that will work seamlessly even if your original type already has snake case keys. If not, the transformation will be as follows: camelCase -> camelcase

type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}`
    ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}`
    : Lowercase<S>

type ObjectToCamel<T> = {
    [K in keyof T as CamelCase<string &K>]: T[K] extends Record<string, K> ? KeysToCamelCase<T[K]> : T[K]
}

type KeysToCamelCase<T> = {
    [K in keyof T as K extends `${infer P1}_${infer P2}`
        ? CamelCase<string &K>
        : K
    ]: T[K] extends Array<K>
        ? KeysToCamelCase<T[K][number]>[]
        : ObjectToCamel<T[K]>
}  

Derived from Max Eisenhardt's response

This function will handle recursively any snake/dashes/specified delimiter present in the key of an object. It also accounts for unrolling array types to maintain the array structures.

/** Transform a string into camel-case based on a specific delimiter */
export type CamelCaseFrom<S extends string, Delimiter extends string> = CamelCaseFromHelper<S, Delimiter>;

type CamelCaseFromHelper<S extends string, Delimiter extends string, NotFirstToken extends boolean = false> =
    NotFirstToken extends true
        ? S extends `${infer P1}${Delimiter}${infer P2}`
            ? `${Capitalize<P1>}${CamelCaseFromHelper<P2, Delimiter, true>}`
            : `${Capitalize<S>}`
        : S extends `${infer P1}${Delimiter}${infer P2}`
            ? `${Lowercase<P1>}${CamelCaseFromHelper<P2, Delimiter, true>}`
            : `${Lowercase<S>}`;

/** Convert keys of an object into camel-case using a specified delimiter */
export type KeysToCamelCase<T, Delimiter extends string> = {
    [K in keyof T as CamelCaseFrom<string &K, Delimiter>]:
        T[K] extends Array<infer ArrayElement>
            ? KeysToCamelCaseForArrayElement<ArrayElement, Delimiter>
            : T[K] extends {}
                ? KeysToCamelCase<T[K], Delimiter>
                : T[K];
}

/** Deals with selecting keys from nested arrays */
type KeysToCamelCaseForArrayElement<AElement, Delimiter extends string> =
    AElement extends Array<infer BElement>
        ? Array<KeysToCamelCaseForArrayElement<BElement, Delimiter>>
        : Array<KeysToCamelCase<AElement, Delimiter>>;

/* ADDITIONAL TYPINGS FOR EASE OF USE */
export type CamelCaseFromKebabCase<S extends string> = CamelCaseFrom<S, '-'>;
export type CamelCaseFromSnakeCase<S extends string> = CamelCaseFrom<S, '_'>;

Example 1

interface MyKebabCaseConfig {
    'foo': string;
    'foo-bar-qaz-pom-dee': string;
    'nested-object': {
        'first-name': string
        'date-of-birth': string;
        'another-one': {
            'aaa-bbb-ccc': string;
        };
        'some-array': string[];
    };
    'array-with-deep-object': SomeDeepObject[][];
}

interface SomeDeepObject {
    'aaa-bbb-ccc': string;
    'deep-array-of-strings': string[][][][];
    'deep-array-of-another-object': {
        'ddd-eee-fff': string;
    }[][][]
}

const transformed: KeysToCamelCase<MyKebabCaseConfig, '-'> = {
    foo: '',
    fooBarQazPomDee: '',
    nestedObject: {
        firstName: '',
        dateOfBirth: '',
        anotherOne: {
            aaaBbbCcc: ''
        },
        someArray: []
    },
    arrayWithDeepObject: [
        [
            {
                aaaBbbCcc: '',
                deepArrayOfStrings: [ [ [ [ '' ] ] ] ],
                deepArrayOfAnotherObject: [ [ [ { dddEeeFff: '' } ] ] ]
            }
        ]
    ]
}

Example 2

interface BangCaseObject {
    'aaa!bbb!ccc': string;
    'eee!ddd': {
        'fff!ggg': string;
    }
}

const x: KeysToCamelCase<BangCaseObject, '!'> = {
    aaaBbbCcc: '',
    eeeDdd: {
        fffGgg: ''
    }
}