It seems to me that perhaps this PR is invalid.
related comments:
#10744 (comment)

in short, the argument data cannot be of type of D because of this:

https://github.com/axios/axios/blob/main/lib/core/transformData.js#L22

utils.forEach(fns, function transform(fn) {
   data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
 });

data is the result type of the function fn and and this is now ==> any

export interface AxiosRequestTransformer<D = any> {
  (this: InternalAxiosRequestConfig<D>, data: D, headers: AxiosRequestHeaders): any;

argument has type of D before the first execution of fn.
and to improve type safety we need to attach a constraint to the result of AxiosRequestTransformer (replace any with D | string | Buffer | ArrayBuffer => #10744 (comment)) and after this to attach a constraint to the data => D | string | Buffer | ArrayBuffer.

type of data must be equal to type of result of AxiosRequestTransformer (because data = fn.call(config, data...)!

I think the current typing is valid only for the first call to transformRequest, but if there is an array of them and the first one does, for example, convert an object to a string or to a Buffer, then the typings will not correspond to what will happen at runtime!

@jasonsaayman

Thanks for digging into this. You're right, transformRequest and transformResponse are left-fold pipelines, so data: D is only honest for the first function in the chain. Once any transformer returns a serialised form (string, Buffer, FormData, whatever), the next one isn't looking at D anymore.

I don't think that invalidates the PR, though. It just means the generic has a narrower scope than a fully sound pipeline type would.

I added a JSDoc on both interfaces. It explains the pipeline semantics, calls out that D/T only describes the first call, warns that later stages may see a serialised form, and says when typing D is safe and when you need a runtime check.

I don't think that invalidates the PR, though. It just means the generic has a narrower scope than a fully sound pipeline type would.

but this is precisely what makes this PR invalid!

It explains the pipeline semantics, calls out that D/T only describes the first call

I added a JSDoc on both interfaces. It explains the pipeline semantics, calls out that D/T only describes the first call, warns that later stages may see a serialised form

But the interface and the code itself don't distinguish between the first call and subsequent calls.
This feels like workaround...
This should be in the typescript constraints, not in the documentation.

then it makes sense to simply not provide the API in order to create more than 1 transform request (but then backward compatibility will be lost)...

and says when typing D is safe and when you need a runtime check.

It turns out that the typings needed for compile-time do not describe what happens at runtime.
then the whole meaning is lost from the using of typescript....

Fair, I agree that is true. I will revert this one as agreed we gain nothing really from this.

Reverted in #10810

we gain nothing really from this.

From typings we get a well documented and type-safety API, this is valuable!
It's just a different type there (not D ==> I think most likely that D | string | Buffer | ArrayBuffer)

Fair, I agree that is true. I will revert this one as agreed we gain nothing really from this.

@jasonsaayman We can make typing improvements that will match what happens at runtime like this (while maintaining backward compatibility):

https://github.com/axios/axios/blob/v1.x/lib/adapters/http.js#L574

interface AxiosRequestTransformer {
    (this: InternalAxiosRequestConfig, data: any, headers: AxiosRequestHeaders): any;
  }


interface AxiosRequestConfig<D = any> {
    transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];

======>

interface FirstAxiosRequestTransformer<D> {
    (this: InternalAxiosRequestConfig, data: D, headers: AxiosRequestHeaders): D | Stream | string | Buffer | ArrayBuffer;
  }
interface AxiosRequestTransformer<D> {
    (this: InternalAxiosRequestConfig, data: D | Stream | string | Buffer | ArrayBuffer, headers: AxiosRequestHeaders): D |  Stream | string | Buffer | ArrayBuffer;
  }
  
  
  
interface AxiosRequestConfig<D = any> {
    transformRequest?: FirstAxiosRequestTransformer | [FirstAxiosRequestTransformer, ...AxiosRequestTransformer[]];

by the way @jasonsaayman

import axios from 'axios';

const instance = axios.create({
  baseURL: 'https://github.com/',
  transformRequest: [
    function (data, headers) {
      return {};
    },
  ],
});

instance.post('/', {});

===>

failed because https://github.com/axios/axios/blob/v1.x/lib/adapters/http.js#L574 ==>

new AxiosError(
              'Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream',
              AxiosError.ERR_BAD_REQUEST,
              config
            )

Am I correct in understanding that the results of chain calls transformRequest must be always Stream | string | Buffer | ArrayBuffer
then we need to improve the constraints here

==>

type ResultOfChainAxiosRequestTransformer = Stream | string | Buffer | ArrayBuffer;

interface FirstAndOnlyAxiosRequestTransformer<D> {
    (this: InternalAxiosRequestConfig, data: D, headers: AxiosRequestHeaders):  ResultOfChainAxiosRequestTransformer;
  }
  
  
  
interface FirstOfChainAxiosRequestTransformer<D> {
    (this: InternalAxiosRequestConfig, data: D, headers: AxiosRequestHeaders): D | ResultOfChainAxiosRequestTransformer;
  }
  
  
interface NotLastOfChainAxiosRequestTransformer<D> {
    (this: InternalAxiosRequestConfig, data: D | ResultOfChainAxiosRequestTransformer, headers: AxiosRequestHeaders): D | ResultOfChainAxiosRequestTransformer;
  }
  
interface LastOfChainAxiosRequestTransformer<D> {
    (this: InternalAxiosRequestConfig, data: D | ResultOfChainAxiosRequestTransformer, headers: AxiosRequestHeaders):  ResultOfChainAxiosRequestTransformer;
  }
  
  
interface AxiosRequestConfig<D = any> {
    transformRequest?: FirstAndOnlyAxiosRequestTransformer | [FirstOfChainAxiosRequestTransformer, ...NotLastOfChainAxiosRequestTransformer[], LastOfChainAxiosRequestTransformer];