axios

  • Version 1.9.0
  • Published
  • 2.16 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 getSetCookie

                                                                                                                              getSetCookie: () => string[];

                                                                                                                                method getUserAgent

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

                                                                                                                                  method has

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

                                                                                                                                    method hasAccept

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

                                                                                                                                      method hasAuthorization

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

                                                                                                                                        method hasContentEncoding

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

                                                                                                                                          method hasContentLength

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

                                                                                                                                            method hasContentType

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

                                                                                                                                              method hasUserAgent

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

                                                                                                                                                method normalize

                                                                                                                                                normalize: (format: boolean) => AxiosHeaders;

                                                                                                                                                  method set

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

                                                                                                                                                    method setAccept

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

                                                                                                                                                      method setAuthorization

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

                                                                                                                                                        method setContentEncoding

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

                                                                                                                                                          method setContentLength

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

                                                                                                                                                            method setContentType

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

                                                                                                                                                              method setUserAgent

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

                                                                                                                                                                method toJSON

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

                                                                                                                                                                  class CanceledError

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

                                                                                                                                                                    Interfaces

                                                                                                                                                                    interface AxiosAdapter

                                                                                                                                                                    interface AxiosAdapter {}

                                                                                                                                                                      call signature

                                                                                                                                                                      (config: InternalAxiosRequestConfig): AxiosPromise;

                                                                                                                                                                        interface AxiosBasicCredentials

                                                                                                                                                                        interface AxiosBasicCredentials {}

                                                                                                                                                                          property password

                                                                                                                                                                          password: string;

                                                                                                                                                                            property username

                                                                                                                                                                            username: string;

                                                                                                                                                                              interface AxiosDefaults

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

                                                                                                                                                                                property headers

                                                                                                                                                                                headers: HeadersDefaults;

                                                                                                                                                                                  interface AxiosInstance

                                                                                                                                                                                  interface AxiosInstance extends Axios {}

                                                                                                                                                                                    property defaults

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

                                                                                                                                                                                      method create

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

                                                                                                                                                                                        call signature

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

                                                                                                                                                                                          call signature

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

                                                                                                                                                                                            interface AxiosInterceptorManager

                                                                                                                                                                                            interface AxiosInterceptorManager<V> {}

                                                                                                                                                                                              property 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 allowAbsoluteUrls

                                                                                                                                                                                                                                              allowAbsoluteUrls?: boolean;

                                                                                                                                                                                                                                                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;

                                                                                                                                                                                                                                                                                                                                                                                          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>