well damn, that worked great

Author: Harris-Miller

test/renameKeys.test.ts

@@ -0,0 +1,19 @@
+import { expectAssignable, expectType } from 'tsd';
+
+import { __, renameKeys } from '../es';
+
+expectType<{ bar: number; other: string }>(renameKeys({ foo: 'bar' })({ foo: 123, other: 'abc' }));
+expectType<{ foo: number; blah: string }>(renameKeys({ other: 'blah' })({ foo: 123, other: 'abc' }));
+
+expectType<{ bar: number; other: string }>(renameKeys(__, { foo: 123, other: 'abc' })({ foo: 'bar' }));
+expectType<{ foo: number; blah: string }>(renameKeys(__, { foo: 123, other: 'abc' })({ other: 'blah' }));
+
+expectType<{ bar: number; other: string }>(renameKeys({ foo: 'bar' }, { foo: 123, other: 'abc' }));
+expectType<{ foo: number; blah: string }>(renameKeys({ other: 'blah' }, { foo: 123, other: 'abc' }));
+
+const nonConstObj = { foo: 'bar' };
+
+const what = renameKeys(nonConstObj, { foo: 123, other: 'abc' });
+//    ^?
+// @ts-expect-error - I have no idea why declaring the type throws an error, but it can be calculated above
+expectAssignable<{ [x: string]: number; other: string; }>(what);

types/renameKeys.d.ts

@@ -1,8 +1,8 @@
-import { Placeholder } from './util/tools';
+import { Placeholder, Prettify, Remap } from './util/tools';
 
 // renameKeys(mapping)(obj)
-export function renameKeys(mapping: Record<string, string>): <T>(obj: Record<string, T>) => Record<string, T>;
+export function renameKeys<const U extends Record<PropertyKey, string>>(mapping: U): <T extends Record<keyof U, unknown>>(obj: T) => Prettify<Omit<T, keyof U> & Remap<T, U>>;
 // renameKeys(__, obj)(mapping)
-export function renameKeys<T>(__: Placeholder, obj: Record<string, T>): (mapping: Record<string, string>) => Record<string, T>;
+export function renameKeys<T>(__: Placeholder, obj: T): <const U extends Partial<Record<keyof T, string>>>(mapping: U) => Prettify<Omit<T, keyof U> & Remap<T, U>>;
 // renameKeys(mapping, obj)
-export function renameKeys<T>(mapping: Record<string, string>, obj: Record<string, T>): Record<string, T>;
+export function renameKeys<T, const U extends Partial<Record<keyof T, string>>>(mapping: U, obj: T): Prettify<Omit<T, keyof U> & Remap<T, U>>;

types/util/tools.d.ts

@@ -520,3 +520,24 @@ export type NonEmptyArray<T> = [T, ...T[]];
  * <created by @harris-miller>
  */
 export type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
+
+/**
+ * Prettify type into an object literal
+ * <created by @harris-miller>
+ */
+export type Prettify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
+
+type TuplesFromObject<T> = {
+  [P in keyof T]: [P, T[P]];
+}[keyof T];
+
+type GetKeyByValue<T, V> =
+  TuplesFromObject<T> extends infer TT
+    ? TT extends [infer P, V]
+      ? P
+      : never
+    : never;
+
+export type Remap<T, U extends { [P in keyof T]?: string }> = {
+  [P in NonNullable<U[keyof U]>]: T[GetKeyByValue<U, P>];
+};