axios

  • Version 1.7.9
  • Published
  • 2.13 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

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable axios

const axios: AxiosStatic;

    Functions

    function all

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

      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: (value: any) => value is Cancel;

              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 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 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_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 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 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> {}

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

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

                                                                                                                                                                                                    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 auth

                                                                                                                                                                                                                                          auth?: AxiosBasicCredentials;

                                                                                                                                                                                                                                            property baseURL

                                                                                                                                                                                                                                            baseURL?: string;

                                                                                                                                                                                                                                              property beforeRedirect

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

                                                                                                                                                                                                                                                property cancelToken

                                                                                                                                                                                                                                                cancelToken?: CancelToken;

                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                  data?: D;

                                                                                                                                                                                                                                                    property decompress

                                                                                                                                                                                                                                                    decompress?: boolean;

                                                                                                                                                                                                                                                      property env

                                                                                                                                                                                                                                                      env?: {
                                                                                                                                                                                                                                                      FormData?: new (...args: any[]) => object;
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        property family

                                                                                                                                                                                                                                                        family?: AddressFamily;

                                                                                                                                                                                                                                                          property fetchOptions

                                                                                                                                                                                                                                                          fetchOptions?: Record<string, any>;

                                                                                                                                                                                                                                                            property formSerializer

                                                                                                                                                                                                                                                            formSerializer?: FormSerializerOptions;

                                                                                                                                                                                                                                                              property headers

                                                                                                                                                                                                                                                              headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders;

                                                                                                                                                                                                                                                                property httpAgent

                                                                                                                                                                                                                                                                httpAgent?: any;

                                                                                                                                                                                                                                                                  property httpsAgent

                                                                                                                                                                                                                                                                  httpsAgent?: any;

                                                                                                                                                                                                                                                                    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?: Method | string;

                                                                                                                                                                                                                                                                                  property onDownloadProgress

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

                                                                                                                                                                                                                                                                                    property onUploadProgress

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

                                                                                                                                                                                                                                                                                      property params

                                                                                                                                                                                                                                                                                      params?: any;

                                                                                                                                                                                                                                                                                        property paramsSerializer

                                                                                                                                                                                                                                                                                        paramsSerializer?: ParamsSerializerOptions | CustomParamsSerializer;

                                                                                                                                                                                                                                                                                          property proxy

                                                                                                                                                                                                                                                                                          proxy?: AxiosProxyConfig | false;

                                                                                                                                                                                                                                                                                            property responseEncoding

                                                                                                                                                                                                                                                                                            responseEncoding?: responseEncoding | string;

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

                                                                                                                                                                                                                                                                                                                                  property config

                                                                                                                                                                                                                                                                                                                                  config: InternalAxiosRequestConfig<D>;

                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                    data: T;

                                                                                                                                                                                                                                                                                                                                      property headers

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

                                                                                                                                                                                                                                                                                                                                                                                    method create

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

                                                                                                                                                                                                                                                                                                                                                                                      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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        link?: RawAxiosRequestHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: RawAxiosRequestHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property patch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            patch: RawAxiosRequestHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property post

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              post: RawAxiosRequestHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property purge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                purge?: RawAxiosRequestHeaders;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property put

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  put: RawAxiosRequestHeaders;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 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 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 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'get'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'GET'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'delete'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'DELETE'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'head'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'HEAD'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'options'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'OPTIONS'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'post'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'POST'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'put'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'PUT'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'patch'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'PATCH'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'purge'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'PURGE'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'link'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'LINK'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'unlink'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'UNLINK';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ascii'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ASCII'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ansi'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ANSI'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'binary'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'BINARY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'base64'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'BASE64'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'base64url'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'BASE64URL'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'hex'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'HEX'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'latin1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'LATIN1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ucs-2'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'UCS-2'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ucs2'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'UCS2'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'utf-8'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'UTF-8'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'utf8'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'UTF8'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'utf16le'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'UTF16LE';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ResponseType

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (57)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto 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>