axios

constructor(config?: AxiosRequestConfig<any, any>);

defaults: AxiosDefaults<any, any>;

interceptors: {
    request: AxiosInterceptorManager<InternalAxiosRequestConfig>;
    response: AxiosInterceptorManager<AxiosResponse>;
};

delete: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

get: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

getUri: (config?: AxiosRequestConfig) => string;

head: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

options: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

patch: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

patchForm: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

post: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

postForm: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

put: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

putForm: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

query: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

request: <T = any, R = AxiosResponseDefault, D = any, P = any>(
    config: AxiosRequestConfig<D, P>
) => Promise<AxiosResponseResult<T, R, D, P>>;

constructor(
    message?: string,
    code?: string,
    config?: InternalAxiosRequestConfig<D, P>,
    request?: any,
    response?: AxiosResponse<T, D, {}, P>
);

cause?: Error;

code?: string;

config?: InternalAxiosRequestConfig<D, P>;

static readonly ECONNABORTED: string;

static readonly ECONNREFUSED: string;

static readonly ERR_BAD_OPTION: string;

static readonly ERR_BAD_OPTION_VALUE: string;

static readonly ERR_BAD_REQUEST: string;

static readonly ERR_BAD_RESPONSE: string;

static readonly ERR_CANCELED: string;

static readonly ERR_DEPRECATED: string;

static readonly ERR_FORM_DATA_DEPTH_EXCEEDED: string;

static readonly ERR_FR_TOO_MANY_REDIRECTS: string;

static readonly ERR_INVALID_URL: string;

static readonly ERR_NETWORK: string;

static readonly ERR_NOT_SUPPORT: string;

static readonly ETIMEDOUT: string;

event?: any;

isAxiosError: boolean;

request?: any;

response?: AxiosResponse<T, D, {}, P>;

status?: number;

toJSON: () => object;

static from: <T = unknown, D = any, P = any>(
    error: Error | unknown,
    code?: string,
    config?: InternalAxiosRequestConfig<D, P>,
    request?: any,
    response?: AxiosResponse<T, D, {}, P>,
    customProps?: object
) => AxiosError<T, D, P>;

constructor(headers?: string | RawAxiosHeaders | AxiosHeaders);

[Symbol.iterator]: () => IterableIterator<[string, AxiosHeaderValue]>;

static accessor: (header: string | string[]) => AxiosHeaders;

clear: (matcher?: AxiosHeaderMatcher) => boolean;

static concat: (
    ...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>
) => AxiosHeaders;

delete: (header: string | string[], matcher?: AxiosHeaderMatcher) => boolean;

static from: (thing?: AxiosHeaders | RawAxiosHeaders | string) => AxiosHeaders;

get: {
    (
        headerName: string,
        parser: typeof AxiosHeaders.parseParameters
    ): AxiosHeaderParameters;
    (headerName: string, parser: RegExp): RegExpExecArray;
    (headerName: string, matcher?: true | AxiosHeaderParser): AxiosHeaderValue;
};

getAccept: {
    (parser?: RegExp): RegExpExecArray | null;
    (matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
};

getAuthorization: {
    (parser?: RegExp): RegExpExecArray | null;
    (matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
};

getContentEncoding: {
    (parser?: RegExp): RegExpExecArray | null;
    (matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
};

getContentLength: {
    (parser?: RegExp): RegExpExecArray | null;
    (matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
};

getContentType: {
    (parser?: RegExp): RegExpExecArray | null;
    (matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
};

getSetCookie: () => string[];

getUserAgent: {
    (parser?: RegExp): RegExpExecArray | null;
    (matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
};

has: (header: string, matcher?: AxiosHeaderMatcher) => boolean;

hasAccept: (matcher?: AxiosHeaderMatcher) => boolean;

hasAuthorization: (matcher?: AxiosHeaderMatcher) => boolean;

hasContentEncoding: (matcher?: AxiosHeaderMatcher) => boolean;

hasContentLength: (matcher?: AxiosHeaderMatcher) => boolean;

hasContentType: (matcher?: AxiosHeaderMatcher) => boolean;

hasUserAgent: (matcher?: AxiosHeaderMatcher) => boolean;

normalize: (format: boolean) => AxiosHeaders;

static parseParameters: (value: AxiosHeaderValue) => AxiosHeaderParameters;

set: {
    (
        headerName?: string,
        value?: AxiosHeaderValue,
        rewrite?: boolean | AxiosHeaderMatcher
    ): AxiosHeaders;
    (
        headers?: string | RawAxiosHeaders | AxiosHeaders,
        rewrite?: boolean
    ): AxiosHeaders;
    (
        headers?: Iterable<[string, AxiosHeaderValue]>,
        rewrite?: boolean
    ): AxiosHeaders;
};

setAccept: (
    value: AxiosHeaderValue,
    rewrite?: boolean | AxiosHeaderMatcher
) => AxiosHeaders;

setAuthorization: (
    value: AxiosHeaderValue,
    rewrite?: boolean | AxiosHeaderMatcher
) => AxiosHeaders;

setContentEncoding: (
    value: AxiosHeaderValue,
    rewrite?: boolean | AxiosHeaderMatcher
) => AxiosHeaders;

setContentLength: (
    value: AxiosHeaderValue,
    rewrite?: boolean | AxiosHeaderMatcher
) => AxiosHeaders;

setContentType: (
    value: ContentType,
    rewrite?: boolean | AxiosHeaderMatcher
) => AxiosHeaders;

setUserAgent: (
    value: AxiosHeaderValue,
    rewrite?: boolean | AxiosHeaderMatcher
) => AxiosHeaders;

toJSON: {
    (asStrings: true): Record<string, string>;
    (asStrings?: false): Record<string, string | string[]>;
    (asStrings?: boolean): Record<string, string | string[]>;
};

toString: () => string;

constructor(
    message?: string,
    config?: InternalAxiosRequestConfig<D, P>,
    request?: any
);

readonly name: string;

(config: InternalAxiosRequestConfig): AxiosPromise;

password: string;

username: string;

headers: HeadersDefaults;

defaults: Omit<AxiosDefaults, 'headers'> & {
    headers: HeadersDefaults & {
        [key: string]: AxiosHeaderValue;
    };
};

create: (config?: CreateAxiosDefaults) => AxiosInstance;

<T = any, R = AxiosResponseDefault, D = any, P = any>(
    config: AxiosRequestConfig<D, P>
): Promise<AxiosResponseResult<T, R, D, P>>;

<T = any, R = AxiosResponseDefault, D = any, P = any>(
    url: string,
    config?: AxiosRequestConfig<D, P>
): Promise<AxiosResponseResult<T, R, D, P>>;

handlers?: Array<AxiosInterceptorHandler<V>>;

use: V extends AxiosResponse
    ? AxiosResponseInterceptorUse<V>
    : AxiosRequestInterceptorUse<V>;

clear: () => void;

eject: (id: number) => void;

runWhen?: ((config: InternalAxiosRequestConfig) => boolean) | null;

synchronous?: boolean;

bytes: number;

download?: boolean;

estimated?: number;

event?: BrowserProgressEvent;

lengthComputable: boolean;

loaded: number;

progress?: number;

rate?: number;

total?: number;

upload?: boolean;

auth?: AxiosBasicCredentials;

host: string;

port: number;

protocol?: string;

adapter?: AxiosAdapterConfig | AxiosAdapterConfig[];

allowAbsoluteUrls?: boolean;

allowedSocketPaths?: string | string[] | null;

auth?: AxiosBasicCredentials;

baseURL?: string;

beforeRedirect?: (
    options: Record<string, any>,
    responseDetails: {
        headers: Record<string, string>;
        statusCode: HttpStatusCode;
    },
    requestDetails: {
        headers: Record<string, string>;
        url: string;
        method: string;
    }
) => void;

cancelToken?: CancelToken | undefined;

data?: D;

decompress?: boolean;

env?: {
    FormData?: new (...args: any[]) => object;
    fetch?: (
        input: URL | Request | string,
        init?: RequestInit
    ) => Promise<Response>;
    Request?: new (input: URL | Request | string, init?: RequestInit) => Request;
    /**
     * Custom Response constructor for the fetch adapter.
     * When response-body streaming is supported, must also accept
     * `ReadableStream<Uint8Array>` bodies at runtime for `onDownloadProgress`,
     * enabled `maxContentLength` limits, or cancellation/timeout tracking with
     * `responseType: 'stream'` or `'response'`.
     * The body parameter retains its legacy type for compatibility.
     */
    Response?: new (
        body?:
            | ArrayBuffer
            | ArrayBufferView
            | Blob
            | FormData
            | URLSearchParams
            | string
            | null,
        init?: ResponseInit
    ) => Response;
};

family?: AddressFamily;

fetchOptions?:
    | Omit<RequestInit, 'body' | 'headers' | 'method' | 'signal'>
    | Record<string, any>;

formDataHeaderPolicy?: 'legacy' | 'content-only';

formSerializer?: FormSerializerOptions;

headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders;

http2Options?: Record<string, any> & {
    sessionTimeout?: number;
};

httpAgent?: any;

httpsAgent?: any;

httpVersion?: 1 | 2;

insecureHTTPParser?: boolean;

lookup?:
    | ((
          hostname: string,
          options: object,
          cb: (
              err: Error | null,
              address: LookupAddress | LookupAddress[],
              family?: AddressFamily
          ) => void
      ) => void)
    | ((
          hostname: string,
          options: object
      ) => Promise<
          | [
                address: LookupAddressEntry | LookupAddressEntry[],
                family?: AddressFamily
            ]
          | LookupAddress
      >);

maxBodyLength?: number;

maxContentLength?: number;

maxRate?: number | [MaxUploadRate, MaxDownloadRate];

maxRedirects?: number;

method?: StringLiteralsOrString<Method>;

onDownloadProgress?: (progressEvent: AxiosProgressEvent) => void;

onUploadProgress?: (progressEvent: AxiosProgressEvent) => void;

params?: P;

paramsSerializer?:
    | ParamsSerializerOptions<unknown extends P ? Record<string, any> : P>
    | CustomParamsSerializer<unknown extends P ? Record<string, any> : P>;

parseReviver?: (
    this: any,
    key: string,
    value: any,
    context?: { source?: string }
) => any;

proxy?: AxiosProxyConfig | false;

redact?: string[];

responseEncoding?: StringLiteralsOrString<responseEncoding>;

responseType?: ResponseType;

sensitiveHeaders?: string[];

signal?: GenericAbortSignal;

socketPath?: string | null;

timeout?: Milliseconds;

timeoutErrorMessage?: string;

transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];

transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[];

transitional?: TransitionalOptions;

transport?: any;

url?: string;

validateStatus?: ((status: number) => boolean) | null;

withCredentials?: boolean;

withXSRFToken?:
    | boolean
    | ((config: InternalAxiosRequestConfig<D, P>) => boolean | undefined);

xsrfCookieName?: string;

xsrfHeaderName?: string;

(this: InternalAxiosRequestConfig, data: any, headers: AxiosRequestHeaders): any;

config: InternalAxiosRequestConfig<D, P>;

data: T;

duration?: number;

headers: (H & RawAxiosResponseHeaders) | AxiosResponseHeaders;

request?: any;

status: number;

statusText: string;

readonly [axiosResponseDefault]: true;

(
    this: InternalAxiosRequestConfig,
    data: any,
    headers: AxiosResponseHeaders,
    status?: number
): any;

all: typeof all;

Axios: typeof Axios;

AxiosError: typeof AxiosError;

AxiosHeaders: typeof AxiosHeaders;

Cancel: typeof CanceledError;

CanceledError: typeof CanceledError;

CancelToken: CancelTokenStatic;

formToJSON: typeof formToJSON;

getAdapter: typeof getAdapter;