axios

axios

Version 1.16.0
Published 17 hours ago
2.76 MB
3 dependencies
MIT license

Install

npm i axios

yarn add axios

pnpm add axios

Overview

Promise based HTTP client for the browser and node.js

Index

Variables

variable axios

const axios: AxiosStatic;

Functions

function all

all: <T>(values: Array<T | Promise<T>>) => Promise<T[]>;

function create

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

function formToJSON

formToJSON: (form: GenericFormData | GenericHTMLFormElement) => object;

function getAdapter

getAdapter: (
    adapters: AxiosAdapterConfig | AxiosAdapterConfig[] | undefined
) => AxiosAdapter;

function isAxiosError

isAxiosError: <T = any, D = any>(payload: any) => payload is AxiosError<T, D>;

function isCancel

isCancel: <T = any>(value: any) => value is CanceledError<T>;

function mergeConfig

mergeConfig: <D = any>(
    config1: AxiosRequestConfig<D>,
    config2: AxiosRequestConfig<D>
) => AxiosRequestConfig<D>;

function spread

spread: <T, R>(callback: (...args: T[]) => R) => (array: T[]) => R;

function toFormData

toFormData: (
    sourceObj: object,
    targetFormData?: GenericFormData,
    options?: FormSerializerOptions
) => GenericFormData;

Classes

class Axios

class Axios {}

constructor

constructor(config?: AxiosRequestConfig<any>);

property defaults

defaults: AxiosDefaults<any>;

property interceptors

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

method delete

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

method get

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

method getUri

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

method head

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

method options

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

method patch

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

method patchForm

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

method post

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

method postForm

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

method put

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

method putForm

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

method query

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

method request

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

class AxiosError

class AxiosError<T = unknown, D = any> extends Error {}

constructor

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

property cause

cause?: Error;

property code

code?: string;

property config

config?: InternalAxiosRequestConfig<D>;

property ECONNABORTED

static readonly ECONNABORTED: string;

property ECONNREFUSED

static readonly ECONNREFUSED: string;

property ERR_BAD_OPTION

static readonly ERR_BAD_OPTION: string;

property ERR_BAD_OPTION_VALUE

static readonly ERR_BAD_OPTION_VALUE: string;

property ERR_BAD_REQUEST

static readonly ERR_BAD_REQUEST: string;

property ERR_BAD_RESPONSE

static readonly ERR_BAD_RESPONSE: string;

property ERR_CANCELED

static readonly ERR_CANCELED: string;

property ERR_DEPRECATED

static readonly ERR_DEPRECATED: string;

property ERR_FORM_DATA_DEPTH_EXCEEDED

static readonly ERR_FORM_DATA_DEPTH_EXCEEDED: string;

property ERR_FR_TOO_MANY_REDIRECTS

static readonly ERR_FR_TOO_MANY_REDIRECTS: string;

property ERR_INVALID_URL

static readonly ERR_INVALID_URL: string;

property ERR_NETWORK

static readonly ERR_NETWORK: string;

property ERR_NOT_SUPPORT

static readonly ERR_NOT_SUPPORT: string;

property ETIMEDOUT

static readonly ETIMEDOUT: string;

property event

event?: any;

property isAxiosError

isAxiosError: boolean;

property request

request?: any;

property response

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

property status

status?: number;

property toJSON

toJSON: () => object;

method from

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

class AxiosHeaders

class AxiosHeaders {}

constructor

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

method [Symbol.iterator]

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

method accessor

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

method clear

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

method concat

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

method delete

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

method from

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

method get

get: {
    (headerName: string, parser: RegExp): RegExpExecArray | null;
    (headerName: string, matcher?: true | AxiosHeaderParser): AxiosHeaderValue;
};

method getAccept

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

method getAuthorization

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

method getContentEncoding

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

method getContentLength

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

method getContentType

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

method getSetCookie

getSetCookie: () => string[];

method getUserAgent

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

method has

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

method hasAccept

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

method hasAuthorization

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

method hasContentEncoding

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

method hasContentLength

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

method hasContentType

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

method hasUserAgent

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

method normalize

normalize: (format: boolean) => AxiosHeaders;

method set

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

method setAccept

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

method setAuthorization

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

method setContentEncoding

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

method setContentLength

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

method setContentType

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

method setUserAgent

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

method toJSON

toJSON: (asStrings?: boolean) => RawAxiosHeaders;

class CanceledError

class CanceledError<T> extends AxiosError<T> {}

property name

readonly name: string;

Interfaces

interface AxiosAdapter

interface AxiosAdapter {}

call signature

(config: InternalAxiosRequestConfig): AxiosPromise;

interface AxiosBasicCredentials

interface AxiosBasicCredentials {}

property password

password: string;

property username

username: string;

interface AxiosDefaults

interface AxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {}

property headers

headers: HeadersDefaults;

interface AxiosInstance

interface AxiosInstance extends Axios {}

property defaults

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

method create

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

call signature

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

call signature

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

interface AxiosInterceptorManager

interface AxiosInterceptorManager<V> {}

property handlers

handlers?: Array<AxiosInterceptorHandler<V>>;

property use

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

method clear

clear: () => void;

method eject

eject: (id: number) => void;

interface AxiosInterceptorOptions

interface AxiosInterceptorOptions {}

property runWhen

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

property synchronous

synchronous?: boolean;

interface AxiosProgressEvent

interface AxiosProgressEvent {}

property bytes

bytes: number;

property download

download?: boolean;

property estimated

estimated?: number;

property event

event?: BrowserProgressEvent;

property lengthComputable

lengthComputable: boolean;

property loaded

loaded: number;

property progress

progress?: number;

property rate

rate?: number;

property total

total?: number;

property upload

upload?: boolean;

interface AxiosProxyConfig

interface AxiosProxyConfig {}

property auth

auth?: AxiosBasicCredentials;

property host

host: string;

property port

port: number;

property protocol

protocol?: string;

interface AxiosRequestConfig

interface AxiosRequestConfig<D = any> {}

property adapter

adapter?: AxiosAdapterConfig | AxiosAdapterConfig[];

property allowAbsoluteUrls

allowAbsoluteUrls?: boolean;

property allowedSocketPaths

allowedSocketPaths?: string | string[] | null;

property auth

auth?: AxiosBasicCredentials;

property baseURL

baseURL?: string;

property beforeRedirect

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

property cancelToken

cancelToken?: CancelToken | undefined;

property data

data?: D;

property decompress

decompress?: boolean;

property env

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

property family

family?: AddressFamily;

property fetchOptions

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

property formDataHeaderPolicy

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

property formSerializer

formSerializer?: FormSerializerOptions;

property headers

headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders;

property http2Options

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

property httpAgent

httpAgent?: any;

property httpsAgent

httpsAgent?: any;

property httpVersion

httpVersion?: 1 | 2;

property insecureHTTPParser

insecureHTTPParser?: boolean;

property lookup

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

property maxBodyLength

maxBodyLength?: number;

property maxContentLength

maxContentLength?: number;

property maxRate

maxRate?: number | [MaxUploadRate, MaxDownloadRate];

property maxRedirects

maxRedirects?: number;

property method

method?: StringLiteralsOrString<Method>;

property onDownloadProgress

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

property onUploadProgress

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

property params

params?: any;

property paramsSerializer

paramsSerializer?: ParamsSerializerOptions | CustomParamsSerializer;

property parseReviver

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

property proxy

proxy?: AxiosProxyConfig | false;

property redact

redact?: string[];

property responseEncoding

responseEncoding?: StringLiteralsOrString<responseEncoding>;

property responseType

responseType?: ResponseType;

property signal

signal?: GenericAbortSignal;

property socketPath

socketPath?: string | null;

property timeout

timeout?: Milliseconds;

property timeoutErrorMessage

timeoutErrorMessage?: string;

property transformRequest

transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];

property transformResponse

transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[];

property transitional

transitional?: TransitionalOptions;

property transport

transport?: any;

property url

url?: string;

property validateStatus

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

property withCredentials

withCredentials?: boolean;

property withXSRFToken

withXSRFToken?:
    | boolean
    | ((config: InternalAxiosRequestConfig) => boolean | undefined);

property xsrfCookieName

xsrfCookieName?: string;

property xsrfHeaderName

xsrfHeaderName?: string;

interface AxiosRequestTransformer

interface AxiosRequestTransformer {}

call signature

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

interface AxiosResponse

interface AxiosResponse<T = any, D = any, H = {}> {}

property config

config: InternalAxiosRequestConfig<D>;

property data

data: T;

property headers

headers: (H & RawAxiosResponseHeaders) | AxiosResponseHeaders;

property request

request?: any;

property status

status: number;

property statusText

statusText: string;

interface AxiosResponseTransformer

interface AxiosResponseTransformer {}

call signature

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

interface AxiosStatic

interface AxiosStatic extends AxiosInstance {}

property all

all: typeof all;

property Axios

Axios: typeof Axios;

property AxiosError

AxiosError: typeof AxiosError;

property AxiosHeaders

AxiosHeaders: typeof AxiosHeaders;

property Cancel

Cancel: CancelStatic;

property CanceledError

CanceledError: typeof CanceledError;

property CancelToken

CancelToken: CancelTokenStatic;

property formToJSON

formToJSON: typeof formToJSON;

property getAdapter

getAdapter: typeof getAdapter;

property HttpStatusCode

HttpStatusCode: typeof HttpStatusCode;

property isAxiosError

isAxiosError: typeof isAxiosError;

property isCancel

isCancel: typeof isCancel;

property mergeConfig

mergeConfig: typeof mergeConfig;

property spread

spread: typeof spread;

property toFormData

toFormData: typeof toFormData;

property VERSION

readonly VERSION: string;

interface Cancel

interface Cancel {}

property message

message: string | undefined;

interface Canceler

interface Canceler {}

call signature

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

interface CancelStatic

interface CancelStatic {}

construct signature

new (message?: string): Cancel;

interface CancelToken

interface CancelToken {}

property promise

promise: Promise<Cancel>;

property reason

reason?: Cancel;

method throwIfRequested

throwIfRequested: () => void;

interface CancelTokenSource

interface CancelTokenSource {}

property cancel

cancel: Canceler;

property token

token: CancelToken;

interface CancelTokenStatic

interface CancelTokenStatic {}

method source

source: () => CancelTokenSource;

construct signature

new (executor: (cancel: Canceler) => void): CancelToken;

interface CreateAxiosDefaults

interface CreateAxiosDefaults<D = any>
    extends Omit<AxiosRequestConfig<D>, 'headers'> {}

property headers

headers?: RawAxiosRequestHeaders | AxiosHeaders | Partial<HeadersDefaults>;

interface CustomParamsSerializer

interface CustomParamsSerializer {}

call signature

(params: Record<string, any>, options?: ParamsSerializerOptions): string;

interface FormDataVisitorHelpers

interface FormDataVisitorHelpers {}

property convertValue

convertValue: (value: any) => any;

property defaultVisitor

defaultVisitor: SerializerVisitor;

property isVisitable

isVisitable: (value: any) => boolean;

interface FormSerializerOptions

interface FormSerializerOptions extends SerializerOptions {}

interface GenericAbortSignal

interface GenericAbortSignal {}

property aborted

readonly aborted: boolean;

property addEventListener

addEventListener?: (...args: any) => any;

property onabort

onabort?: ((...args: any) => any) | null;

property removeEventListener

removeEventListener?: (...args: any) => any;

interface GenericFormData

interface GenericFormData {}

method append

append: (name: string, value: any, options?: any) => any;

interface GenericHTMLFormElement

interface GenericHTMLFormElement {}

property method

method: string;

property name

name: string;

method submit

submit: () => void;

interface HeadersDefaults

interface HeadersDefaults {}

property common

common: RawAxiosRequestHeaders;

property delete

delete: RawAxiosRequestHeaders;

property get

get: RawAxiosRequestHeaders;

property head

head: RawAxiosRequestHeaders;

property link

link?: RawAxiosRequestHeaders;

property options

options?: RawAxiosRequestHeaders;

property patch

patch: RawAxiosRequestHeaders;

property post

post: RawAxiosRequestHeaders;

property purge

purge?: RawAxiosRequestHeaders;

property put

put: RawAxiosRequestHeaders;

property query

query?: RawAxiosRequestHeaders;

property unlink

unlink?: RawAxiosRequestHeaders;

interface InternalAxiosRequestConfig

interface InternalAxiosRequestConfig<D = any> extends AxiosRequestConfig<D> {}

property headers

headers: AxiosRequestHeaders;

interface LookupAddressEntry

interface LookupAddressEntry {}

property address

address: string;

property family

family?: AddressFamily;

interface ParamEncoder

interface ParamEncoder {}

call signature

(value: any, defaultEncoder: (value: any) => any): any;

interface ParamsSerializerOptions

interface ParamsSerializerOptions extends SerializerOptions {}

property encode

encode?: ParamEncoder;

property serialize

serialize?: CustomParamsSerializer;

interface RawAxiosHeaders

interface RawAxiosHeaders {}

index signature

[key: string]: AxiosHeaderValue;

interface SerializerOptions

interface SerializerOptions {}

property dots

dots?: boolean;

property indexes

indexes?: boolean | null;

property metaTokens

metaTokens?: boolean;

property visitor

visitor?: SerializerVisitor;

interface SerializerVisitor

interface SerializerVisitor {}

call signature

(
    this: GenericFormData,
    value: any,
    key: string | number,
    path: null | Array<string | number>,
    helpers: FormDataVisitorHelpers
): boolean;

interface TransitionalOptions

interface TransitionalOptions {}

property clarifyTimeoutError

clarifyTimeoutError?: boolean;

property forcedJSONParsing

forcedJSONParsing?: boolean;

property legacyInterceptorReqResOrdering

legacyInterceptorReqResOrdering?: boolean;

property silentJSONParsing

silentJSONParsing?: boolean;

Enums

enum HttpStatusCode

enum HttpStatusCode {
    Continue = 100,
    SwitchingProtocols = 101,
    Processing = 102,
    EarlyHints = 103,
    Ok = 200,
    Created = 201,
    Accepted = 202,
    NonAuthoritativeInformation = 203,
    NoContent = 204,
    ResetContent = 205,
    PartialContent = 206,
    MultiStatus = 207,
    AlreadyReported = 208,
    ImUsed = 226,
    MultipleChoices = 300,
    MovedPermanently = 301,
    Found = 302,
    SeeOther = 303,
    NotModified = 304,
    UseProxy = 305,
    Unused = 306,
    TemporaryRedirect = 307,
    PermanentRedirect = 308,
    BadRequest = 400,
    Unauthorized = 401,
    PaymentRequired = 402,
    Forbidden = 403,
    NotFound = 404,
    MethodNotAllowed = 405,
    NotAcceptable = 406,
    ProxyAuthenticationRequired = 407,
    RequestTimeout = 408,
    Conflict = 409,
    Gone = 410,
    LengthRequired = 411,
    PreconditionFailed = 412,
    PayloadTooLarge = 413,
    UriTooLong = 414,
    UnsupportedMediaType = 415,
    RangeNotSatisfiable = 416,
    ExpectationFailed = 417,
    ImATeapot = 418,
    MisdirectedRequest = 421,
    UnprocessableEntity = 422,
    Locked = 423,
    FailedDependency = 424,
    TooEarly = 425,
    UpgradeRequired = 426,
    PreconditionRequired = 428,
    TooManyRequests = 429,
    RequestHeaderFieldsTooLarge = 431,
    UnavailableForLegalReasons = 451,
    InternalServerError = 500,
    NotImplemented = 501,
    BadGateway = 502,
    ServiceUnavailable = 503,
    GatewayTimeout = 504,
    HttpVersionNotSupported = 505,
    VariantAlsoNegotiates = 506,
    InsufficientStorage = 507,
    LoopDetected = 508,
    NotExtended = 510,
    NetworkAuthenticationRequired = 511,
}

member Accepted

Accepted = 202

member AlreadyReported

AlreadyReported = 208

member BadGateway

BadGateway = 502

member BadRequest

BadRequest = 400

member Conflict

Conflict = 409

member Continue

Continue = 100

member Created

Created = 201

member EarlyHints

EarlyHints = 103

member ExpectationFailed

ExpectationFailed = 417

member FailedDependency

FailedDependency = 424

member Forbidden

Forbidden = 403

member Found

Found = 302

member GatewayTimeout

GatewayTimeout = 504

member Gone

Gone = 410

member HttpVersionNotSupported

HttpVersionNotSupported = 505

member ImATeapot

ImATeapot = 418

member ImUsed

ImUsed = 226

member InsufficientStorage

InsufficientStorage = 507

member InternalServerError

InternalServerError = 500

member LengthRequired

LengthRequired = 411

member Locked

Locked = 423

member LoopDetected

LoopDetected = 508

member MethodNotAllowed

MethodNotAllowed = 405

member MisdirectedRequest

MisdirectedRequest = 421

member MovedPermanently

MovedPermanently = 301

member MultipleChoices

MultipleChoices = 300

member MultiStatus

MultiStatus = 207

member NetworkAuthenticationRequired

NetworkAuthenticationRequired = 511

member NoContent

NoContent = 204

member NonAuthoritativeInformation

NonAuthoritativeInformation = 203

member NotAcceptable

NotAcceptable = 406

member NotExtended

NotExtended = 510

member NotFound

NotFound = 404

member NotImplemented

NotImplemented = 501

member NotModified

NotModified = 304

member Ok

Ok = 200

member PartialContent

PartialContent = 206

member PayloadTooLarge

PayloadTooLarge = 413

member PaymentRequired

PaymentRequired = 402

member PermanentRedirect

PermanentRedirect = 308

member PreconditionFailed

PreconditionFailed = 412

member PreconditionRequired

PreconditionRequired = 428

member Processing

Processing = 102

member ProxyAuthenticationRequired

ProxyAuthenticationRequired = 407

member RangeNotSatisfiable

RangeNotSatisfiable = 416

member RequestHeaderFieldsTooLarge

RequestHeaderFieldsTooLarge = 431

member RequestTimeout

RequestTimeout = 408

member ResetContent

ResetContent = 205

member SeeOther

SeeOther = 303

member ServiceUnavailable

ServiceUnavailable = 503

member SwitchingProtocols

SwitchingProtocols = 101

member TemporaryRedirect

TemporaryRedirect = 307

member TooEarly

TooEarly = 425

member TooManyRequests

TooManyRequests = 429

member Unauthorized

Unauthorized = 401

member UnavailableForLegalReasons

UnavailableForLegalReasons = 451

member UnprocessableEntity

UnprocessableEntity = 422

member UnsupportedMediaType

UnsupportedMediaType = 415

member Unused

Unused = 306

member UpgradeRequired

UpgradeRequired = 426

member UriTooLong

UriTooLong = 414

member UseProxy

UseProxy = 305

member VariantAlsoNegotiates

VariantAlsoNegotiates = 506

Type Aliases

type AddressFamily

type AddressFamily = 4 | 6 | undefined;

type AxiosHeaderValue

type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;

type AxiosPromise

type AxiosPromise<T = any> = Promise<AxiosResponse<T>>;

type AxiosRequestHeaders

type AxiosRequestHeaders = RawAxiosRequestHeaders & AxiosHeaders;

type AxiosResponseHeaders

type AxiosResponseHeaders = RawAxiosResponseHeaders & AxiosHeaders;

type LookupAddress

type LookupAddress = string | LookupAddressEntry;

type Method

type Method = (UppercaseMethod | Lowercase<UppercaseMethod>) & {};

type RawAxiosRequestConfig

type RawAxiosRequestConfig<D = any> = AxiosRequestConfig<D>;

type RawAxiosRequestHeaders

type RawAxiosRequestHeaders = Partial<
    RawAxiosHeaders & {
        [Key in CommonRequestHeadersList]: AxiosHeaderValue;
    } & {
        'Content-Type': ContentType;
    }
>;

type RawAxiosResponseHeaders

type RawAxiosResponseHeaders = Partial<RawAxiosHeaders & RawCommonResponseHeaders>;

type responseEncoding

type responseEncoding = (
    | UppercaseResponseEncoding
    | Lowercase<UppercaseResponseEncoding>
) & {};

type ResponseType

type ResponseType =
    | 'arraybuffer'
    | 'blob'
    | 'document'
    | 'json'
    | 'text'
    | 'stream'
    | 'formdata';

Package Files (1)

index.d.ts

Dependencies (3)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/axios.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/axios)

HTML

<a href="https://www.jsdocs.io/package/axios"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated just now.
Package analyzed in 5617 ms.
Missing or incorrect documentation? Open an issue for this package.