How can I derive types from function argument?

I want a function createApi that will infer types based on the config passed in.

Here is what I have so far:

export type EndpointConfig<Input, Resp> = (http: Http) => RequestConfig<Input, Resp>;

export type RequestConfig<Input, Resp> = {
  query: (input: Input) => Promise<Resp>
}

export type ApiConfig<M extends EndpointMap> = {
  endpoints: { [K in keyof M]: EndpointConfig<M[K]['input'], M[K]['resp']> }
}

type EndpointMap = { [key: string]: { resp: any, input: any } };

export const createApi = <M extends EndpointMap>(config: ApiConfig<M>): ApiConfig<M> => {
  // omit implementation
  return config;
};

export interface Http {
  get: <T>(url: string) => Promise<T>
}

// ============ using createApi ============

interface User {
  username: string
}

export const api = createApi({
  endpoints: {
    users: http => ({
      // here is where the types should come from
      query: (input: string) => http.get<User>(`/users/${input}`),
    }),
  },
});

const { users } = api.endpoints;
// typeof users is EndpointConfig<any, any>
// but I want EndpointConfig<string, User>

Given a value of type

type ApiConfig<M extends EndpointMap> = {
  endpoints: { [K in keyof M]: EndpointConfig<M[K]['input'], M[K]['resp']> }
}

for some M, the compiler really can't properly infer M from it. To do so would require that types could be synthesized from arbitrary indexed access types like T['input'] or T['resp'], but TypeScript doesn't currently do that. There's an open feature request for it at microsoft/TypeScript#51612, but for now it's not part of the language.

Until an unless that gets implemented you'll need to work around it. It's a lot easier to infer a type parameter to be exactly the type of the passed in function argument, and then evaluate your desired type from that. So instead of config: ApiConfig<M>, you'd have config: {endpoints: E} and then return either E or some type that is computed from E. For example:

export const createApi = <
  E extends Record<keyof E, EndpointConfig<any, any>>
>(config: { endpoints: E }): {
  endpoints: { [K in keyof E]:
    E[K] extends EndpointConfig<infer I, infer R> ?
    EndpointConfig<I, R> : E[K]
  }
} => {
  // omit implementation
  return config;
};

And now when we test it:

export const api = createApi({
  endpoints: {
    users: http => ({
      query: (input: string) => http.get<User>(`/users/${input}`),
    }),
  },
});

/* const api: {
    endpoints: {
        users: EndpointConfig<string, User>;
    };
} */

const { users } = api.endpoints;
// const users: EndpointConfig<string, User>

You get the behavior you're looking for.

Playground link to code