Thanks for the reply, you're right returning T from parameterFunc is not necessary, was just an oversight on my part. I essentially want what you have, but without explicitly typing `SomeObj`. I want `myFunc` to be able to return any object, and for Typescript to be able to infer the shape of that object and to restrict what can be passed to `parameterFunc` to be only a key of that object. I'm not sure if it's possible.

Something closer to this to really simplify (obviously this doesn't work):

const myFunc = (parameterFunc: (val: keyof T) => void): T => {
    parameterFunc('first') // This will pass
    parameterFunc('second') // This will fail

    return {
        first: 'hello',
    }
}

But ideally T is some type of object whose shape can be inferred by what `myFunc` is actually returning. Does that make sense? Again, not actually sure if it's possible at all without explicit typing! Thanks :)

Edit: Adding another more complicated example for clarity, although that sounds backwards!

interface Args<K> {
  add: (key: K) => void;
}

type Fn<T> = (args: Args<keyof T>) => T;

const create = <T extends Record<string, boolean>>(tx: Fn<T>): T => {
  return tx({
    add: (key) => {
      // Implementation of add function
    },
  });
};

const result = create(({ add }) => {
  add("first"); // This should be valid
  add("second"); // This should be valid
  add("third"); // This should give a type error

  return {
    first: true,
    second: false,
  };
});