Converting input object type in TypeScript

I need to alternate the type of an object passed to a function, so every method inside the object receive a modified this:

create({
  /*
   * Hello
   */
  foo(): string {
    console.log(this); // should be { foo: string, bar: number, baz: Record<string, number> }
    console.log(this.bar); // should be number
    console.log(this.baz); // should be Record<string, number>
    return "Hello";
  },


  /*
   * World
   */
  bar(): number {
    console.log(this.foo); // should be string
    console.log(this.baz); // should be Record<string, number>
    return 123;
  },

  /*
   * World
   */
  baz(): Record<string, number> {
    console.log(this.foo); // should be string
    console.log(this.bar); // should be number
    return {
      foo: 123,
      bar: 456,
    };
  },
});

For the create function I tried the following approach without much of a success:

type PropMethod = () => any;

type Property<P extends PropMethod = any> = P extends PropMethod ? P : never;

type Context<T extends Record<string, Property>> = {
  [K in keyof T]: T[K] extends Property ? ReturnType<T[K]> : never;
};

type Properties<P extends Record<string, Property>> = {
  [K in keyof P]: P[K] extends (...args: infer Args) => infer R
    ? (this: Context<P>, ...args: Args) => R
    : never;
};

function create<
  C extends Record<string, Property>,
>(input: Properties<C>) {
  /**
   * Body implementation
   */
}

Obviously, I'm getting this: Context<Record<string, any>> and every property inside the functions is any too.

Is it even possible to achieve such typing with TS? One of the requirements is that there should be no hardcoded types and as the whole thing is an abstraction.

Also, it'd be awesome if someone could suggest a better title for the question.

As far as I know the only way to get the kind of behavior you're looking for is to use the "magic" ThisType<T> utility type. It's "magic" because even though the definition of ThisType<T> it is just an empty interface, it is special-cased by the compiler to indicate the type you want the this context of methods to be treated as.

Here's how I'd use it for your code:

function create<M extends object>(input:
  M & ThisType<{ [K in keyof M]:
    M[K] extends (...args: any) => infer R ? R : M[K]
  }>) { }

So I'm saying that the type of input is the generic M, but that the this context of its properties should be inferred as

{ [K in keyof M]: M[K] extends (...args: any) => infer R ? R : M[K] }

where we're mapping the methods of M to just their return types via conditional type inference

Let's test it out:

create({
  foo(): string {
    this.bar.toFixed(); // okay
    Object.values(this.baz).map(x => x.toFixed()); // okay
    return "Hello";
  },
  bar(): number {
    this.foo.toUpperCase(); // okay
    Object.values(this.baz).map(x => x.toFixed()); // okay
    return 123;
  },
  baz(): Record<string, number> {
    this.foo.toUpperCase(); // okay
    this.bar.toFixed(); // okay
    return {
      foo: 123,
      bar: 456,
    };
  },
});

Looks good! The types of this.foo, this.bar, and this.baz are exactly what you wanted them to be.

Playground link to code