axios

constructor(config?: AxiosRequestConfig<any>);

defaults: AxiosDefaults<any>;

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

delete: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

get: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

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

head: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

options: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

patch: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

patchForm: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

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

postForm: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

put: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

putForm: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

query: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig<D>
) => Promise<R>;

request: <T = any, R = AxiosResponse<T, any, {}>, D = any>(
    config: AxiosRequestConfig<D>
) => Promise<R>;

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

cause?: Error;

code?: string;

config?: InternalAxiosRequestConfig<D>;

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, {}>;

status?: number;

toJSON: () => object;

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

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: RegExp): RegExpExecArray | null;
    (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;

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<any>,
    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 = AxiosResponse<T>, D = any>(
    config: AxiosRequestConfig<D>
): Promise<R>;

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

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;
    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?: any;

paramsSerializer?: ParamsSerializerOptions | CustomParamsSerializer;

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) => boolean | undefined);

xsrfCookieName?: string;

xsrfHeaderName?: string;

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

config: InternalAxiosRequestConfig<D>;

data: T;

headers: (H & RawAxiosResponseHeaders) | AxiosResponseHeaders;

request?: any;

status: number;

statusText: string;

(
    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;

HttpStatusCode: typeof HttpStatusCode;

isAxiosError: typeof isAxiosError;

isCancel: typeof isCancel;

mergeConfig: typeof mergeConfig;

spread: typeof spread;

toFormData: typeof toFormData;

readonly VERSION: string;

message: string | undefined;

(message?: string, config?: AxiosRequestConfig, request?: any): void;

new (message?: string): Cancel;

promise: Promise<Cancel>;

reason?: Cancel;

subscribe: (listener: (cancel: Cancel | any) => void) => void;

throwIfRequested: () => void;

toAbortSignal: () => AbortSignal;

unsubscribe: (listener: (cancel: Cancel | any) => void) => void;

cancel: Canceler;

token: CancelToken;