Is it possible to provide generic type args by name?

Say there is a generic type defined that provides both named args and default types for the generic args. Like this type from axios lib:

post<T = any, R = AxiosResponse<T>, D = any>

I can specify the response type quite easily, since it is the first arg and the other args have defaults:

myClient.post<MyResponseType>(...)

I would like to be able to specify the request body type as well, which is the D arg to the generic type.

But it's awkward because there is the derived param R in the middle... which I never want to manually specify. So I can't do:

myClient.post<MyResponseType, MyRequestType>(...)

I'd have to redundantly spell it out like:

myClient.post<MyResponseType, AxiosResponse<MyResponseType>, MyRequestType>(...)

...which is long-winded and ugly.

AFAICT there is no shorthand in TS, e.g. I can't do:

myClient.post<MyResponseType, D=MyRequestType>(...)

(which seems to beg the question why bother having named generic args)

Is there any trick I could use to annotate my post calls with both request and response types in a clean and concise way?

Based on the current axios/v1.x/index.d.ts type defintions, you should be able to just extend export class Axios in your own .ts file to add an overload of Axios.post with different type-parameters.

TypeScript, like JavaScript, doesn't support overloaded function implementations, but it does allow for overloaded function signatures, including overloaded generic type parameters.

So the Axios index.d.ts has something like this (cut-down for brevity):

export class Axios {
    // ...
    post<T = any, R = AxiosResponse<T>, D = any>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<R>;
    // ...
}

TypeScript code that consumes export class definitions from a d.ts can extend those classes by extending the class's implicit interface, so in your own code, somewhere near the top of your .ts file, you'd simply put something like this:

declare interface Axios {
  post<T,D>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<T>>;
}

Because the function parameters (url, data, and config) and its Promise<AxiosResponse<T>> are all compatible with the underlying implementation and don't conflict with the declared post function in index.d.ts this is fine.

...of course, the problem is getting TypeScript to recognize that this interface Axios is actually intended to be merged-into-and-extend the class Axios from the imported library, rather than being a completely separate Axios type. And things get muddied considering how the module system works differently to the old-world global namespace.

So...

If you're using import { Axios } from 'axios':

// Step 1. Import Axios:
import { Axios, AxiosRequestConfig, AxiosResponse } from 'axios';

// Step 2. Extend Axios:
declare module 'axios' {
  interface Axios {
    post<T,D>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<T>>;
  }
}

// Step 3. Use Axios:
interface MyRequestDto {
    readonly foobar: string;
}
interface MyResponseDto {
  readonly qux: string;
}

async function foo() {

    const reqDto: MyRequestDto = { foobar: "hmm" };

    const a = new Axios();

    // Look ma! Only two explicit type-parameters!
    const resp = await a.post<MyResponseDto,MyRequestDto>( '/foo', reqDto ); 
    const responseDto: MyResponseDto = resp.data;
    console.log( responseDto.qux );
}

If you're using non-module, global, or /// <reference types="axios" />:

(Disclaimer: I'm not able to provide a complete and working self-contained example because I can't figure out how to get /// <reference types="" />-style imports of index.d.ts files to work yet, but provided that your code is already currently using Axios just fine then all you need is the declare interface Axios part)

// Step 1. Import Axios... somehow:
/// <reference types="axios" />
/// <reference path="axios/index.d.ts" />
/// <reference pleasepleasepleaseworkdamnit="axios" />

// Step 2. Extend Axios:
declare interface Axios {
  post<T,D>(url: string, data?: D, config?: AxiosRequestConfig<D>): Promise<AxiosResponse<T>>;
}

// Step 3. Use Axios:
interface MyRequestDto {
    readonly foobar: string;
}
interface MyResponseDto {
  readonly qux: string;
}

async function foo() {

    const reqDto: MyRequestDto = { foobar: "hmm" };

    const a = new Axios();

    // Look ma! Only two explicit type-parameters!
    const resp = await a.post<MyResponseDto,MyRequestDto>( '/foo', reqDto ); 
    const responseDto: MyResponseDto = resp.data;
    console.log( responseDto.qux );
}