@openclaw/feishu 2026.7.2-beta.5 → 2026.7.33

package/node_modules/@larksuiteoapi/node-sdk/node_modules/axios/index.d.cts

@@ -0,0 +1,766 @@
+type MethodsHeaders = Partial<
+  {
+    [Key in axios.Method as Lowercase<Key>]: AxiosHeaders;
+  } & { common: AxiosHeaders }
+>;
+
+type AxiosHeaderMatcher =
+  | string
+  | RegExp
+  | ((this: AxiosHeaders, value: string, name: string) => boolean);
+
+type AxiosHeaderParser = (this: AxiosHeaders, value: axios.AxiosHeaderValue, header: string) => any;
+
+type CommonRequestHeadersList =
+  | 'Accept'
+  | 'Content-Length'
+  | 'User-Agent'
+  | 'Content-Encoding'
+  | 'Authorization'
+  | 'Location';
+
+type ContentType =
+  | axios.AxiosHeaderValue
+  | 'text/html'
+  | 'text/plain'
+  | 'multipart/form-data'
+  | 'application/json'
+  | 'application/x-www-form-urlencoded'
+  | 'application/octet-stream';
+
+type CommonResponseHeadersList =
+  | 'Server'
+  | 'Content-Type'
+  | 'Content-Length'
+  | 'Cache-Control'
+  | 'Content-Encoding';
+
+type CommonResponseHeaderKey = CommonResponseHeadersList | Lowercase<CommonResponseHeadersList>;
+
+type BrowserProgressEvent = any;
+
+declare class AxiosHeaders {
+  constructor(headers?: axios.RawAxiosHeaders | AxiosHeaders | string);
+
+  [key: string]: any;
+
+  set(
+    headerName?: string,
+    value?: axios.AxiosHeaderValue,
+    rewrite?: boolean | AxiosHeaderMatcher
+  ): AxiosHeaders;
+  set(headers?: axios.RawAxiosHeaders | AxiosHeaders | string, rewrite?: boolean): AxiosHeaders;
+  set(headers?: Iterable<[string, axios.AxiosHeaderValue]>, rewrite?: boolean): AxiosHeaders;
+
+  get(
+    headerName: string,
+    parser: typeof AxiosHeaders.parseParameters
+  ): axios.AxiosHeaderParameters;
+  get(headerName: string, parser: RegExp): RegExpExecArray | null;
+  get(headerName: string, matcher?: true | AxiosHeaderParser): axios.AxiosHeaderValue;
+
+  has(header: string, matcher?: AxiosHeaderMatcher): boolean;
+
+  delete(header: string | string[], matcher?: AxiosHeaderMatcher): boolean;
+
+  clear(matcher?: AxiosHeaderMatcher): boolean;
+
+  normalize(format: boolean): AxiosHeaders;
+
+  concat(
+    ...targets: Array<AxiosHeaders | axios.RawAxiosHeaders | string | undefined | null>
+  ): AxiosHeaders;
+
+  toJSON(asStrings: true): Record<string, string>;
+  toJSON(asStrings?: false): Record<string, string | string[]>;
+  toJSON(asStrings?: boolean): Record<string, string | string[]>;
+
+  static from(thing?: AxiosHeaders | axios.RawAxiosHeaders | string): AxiosHeaders;
+
+  static parseParameters(value: axios.AxiosHeaderValue): axios.AxiosHeaderParameters;
+
+  static accessor(header: string | string[]): AxiosHeaders;
+
+  static concat(
+    ...targets: Array<AxiosHeaders | axios.RawAxiosHeaders | string | undefined | null>
+  ): AxiosHeaders;
+
+  setContentType(value: ContentType, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
+  getContentType(parser?: RegExp): RegExpExecArray | null;
+  getContentType(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
+  hasContentType(matcher?: AxiosHeaderMatcher): boolean;
+
+  setContentLength(
+    value: axios.AxiosHeaderValue,
+    rewrite?: boolean | AxiosHeaderMatcher
+  ): AxiosHeaders;
+  getContentLength(parser?: RegExp): RegExpExecArray | null;
+  getContentLength(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
+  hasContentLength(matcher?: AxiosHeaderMatcher): boolean;
+
+  setAccept(value: axios.AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
+  getAccept(parser?: RegExp): RegExpExecArray | null;
+  getAccept(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
+  hasAccept(matcher?: AxiosHeaderMatcher): boolean;
+
+  setUserAgent(value: axios.AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
+  getUserAgent(parser?: RegExp): RegExpExecArray | null;
+  getUserAgent(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
+  hasUserAgent(matcher?: AxiosHeaderMatcher): boolean;
+
+  setContentEncoding(
+    value: axios.AxiosHeaderValue,
+    rewrite?: boolean | AxiosHeaderMatcher
+  ): AxiosHeaders;
+  getContentEncoding(parser?: RegExp): RegExpExecArray | null;
+  getContentEncoding(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
+  hasContentEncoding(matcher?: AxiosHeaderMatcher): boolean;
+
+  setAuthorization(
+    value: axios.AxiosHeaderValue,
+    rewrite?: boolean | AxiosHeaderMatcher
+  ): AxiosHeaders;
+  getAuthorization(parser?: RegExp): RegExpExecArray | null;
+  getAuthorization(matcher?: AxiosHeaderMatcher): axios.AxiosHeaderValue;
+  hasAuthorization(matcher?: AxiosHeaderMatcher): boolean;
+
+  getSetCookie(): string[];
+
+  toString(): string;
+
+  [Symbol.iterator](): IterableIterator<[string, axios.AxiosHeaderValue]>;
+}
+
+declare class AxiosError<T = unknown, D = any, P = any> extends Error {
+  constructor(
+    message?: string,
+    code?: string,
+    config?: axios.InternalAxiosRequestConfig<D, P>,
+    request?: any,
+    response?: axios.AxiosResponse<T, D, {}, P>
+  );
+
+  config?: axios.InternalAxiosRequestConfig<D, P>;
+  code?: string;
+  request?: any;
+  response?: axios.AxiosResponse<T, D, {}, P>;
+  isAxiosError: boolean;
+  status?: number;
+  toJSON: () => object;
+  cause?: Error;
+  event?: BrowserProgressEvent;
+  static from<T = unknown, D = any, P = any>(
+    error: Error | unknown,
+    code?: string,
+    config?: axios.InternalAxiosRequestConfig<D, P>,
+    request?: any,
+    response?: axios.AxiosResponse<T, D, {}, P>,
+    customProps?: object
+  ): AxiosError<T, D, P>;
+  static readonly ERR_FR_TOO_MANY_REDIRECTS = 'ERR_FR_TOO_MANY_REDIRECTS';
+  static readonly ERR_BAD_OPTION_VALUE = 'ERR_BAD_OPTION_VALUE';
+  static readonly ERR_BAD_OPTION = 'ERR_BAD_OPTION';
+  static readonly ERR_NETWORK = 'ERR_NETWORK';
+  static readonly ERR_DEPRECATED = 'ERR_DEPRECATED';
+  static readonly ERR_BAD_RESPONSE = 'ERR_BAD_RESPONSE';
+  static readonly ERR_BAD_REQUEST = 'ERR_BAD_REQUEST';
+  static readonly ERR_NOT_SUPPORT = 'ERR_NOT_SUPPORT';
+  static readonly ERR_INVALID_URL = 'ERR_INVALID_URL';
+  static readonly ERR_CANCELED = 'ERR_CANCELED';
+  static readonly ERR_FORM_DATA_DEPTH_EXCEEDED = 'ERR_FORM_DATA_DEPTH_EXCEEDED';
+  static readonly ECONNABORTED = 'ECONNABORTED';
+  static readonly ECONNREFUSED = 'ECONNREFUSED';
+  static readonly ETIMEDOUT = 'ETIMEDOUT';
+}
+
+declare class CanceledError<T, D = any, P = any> extends AxiosError<T, D, P> {
+  constructor(message?: string, config?: axios.InternalAxiosRequestConfig<D, P>, request?: any);
+  readonly name: 'CanceledError';
+  __CANCEL__?: boolean;
+}
+
+declare const axiosResponseDefault: unique symbol;
+
+type AxiosResponseDefault = typeof axiosResponseDefault;
+
+type AxiosResponseResult<T, R, D, P> = R extends AxiosResponseDefault
+  ? axios.AxiosResponse<T, D, {}, P>
+  : R;
+
+declare class Axios {
+  constructor(config?: axios.AxiosRequestConfig);
+  defaults: axios.AxiosDefaults;
+  interceptors: {
+    request: axios.AxiosInterceptorManager<axios.InternalAxiosRequestConfig>;
+    response: axios.AxiosInterceptorManager<axios.AxiosResponse>;
+  };
+  getUri(config?: axios.AxiosRequestConfig): string;
+  request<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    config: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  get<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  delete<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  head<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  options<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  post<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    data?: D,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  put<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    data?: D,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  patch<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    data?: D,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  postForm<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    data?: D,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  putForm<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    data?: D,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  patchForm<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    data?: D,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+  query<T = any, R = AxiosResponseDefault, D = any, P = any>(
+    url: string,
+    data?: D,
+    config?: axios.AxiosRequestConfig<D, P>
+  ): Promise<AxiosResponseResult<T, R, D, P>>;
+}
+
+declare 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,
+  /** @deprecated Use `ContentTooLarge` instead. */
+  PayloadTooLarge = 413,
+  ContentTooLarge = 413,
+  UriTooLong = 414,
+  UnsupportedMediaType = 415,
+  RangeNotSatisfiable = 416,
+  ExpectationFailed = 417,
+  ImATeapot = 418,
+  MisdirectedRequest = 421,
+  /** @deprecated Use `UnprocessableContent` instead. */
+  UnprocessableEntity = 422,
+  UnprocessableContent = 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,
+  WebServerReturnsAnUnknownError = 520,
+  WebServerIsDown = 521,
+  ConnectionTimedOut = 522,
+  OriginIsUnreachable = 523,
+  TimeoutOccurred = 524,
+  SslHandshakeFailed = 525,
+  InvalidSslCertificate = 526,
+}
+
+type InternalAxiosError<T = unknown, D = any, P = any> = AxiosError<T, D, P>;
+
+declare namespace axios {
+  type AxiosHeaderParameters = Record<string, string>;
+
+  type AxiosError<T = unknown, D = any, P = any> = InternalAxiosError<T, D, P>;
+
+  interface RawAxiosHeaders {
+    [key: string]: AxiosHeaderValue;
+  }
+
+  type RawAxiosRequestHeaders = Partial<
+    RawAxiosHeaders & {
+      [Key in CommonRequestHeadersList]: AxiosHeaderValue;
+    } & {
+      'Content-Type': ContentType;
+    }
+  >;
+
+  type AxiosRequestHeaders = RawAxiosRequestHeaders & AxiosHeaders;
+
+  type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;
+
+  type RawCommonResponseHeaders = {
+    [Key in CommonResponseHeaderKey]: AxiosHeaderValue;
+  } & {
+    'set-cookie': string[];
+  };
+
+  type RawAxiosResponseHeaders = Partial<RawAxiosHeaders & RawCommonResponseHeaders>;
+
+  type AxiosResponseHeaders = RawAxiosResponseHeaders & AxiosHeaders;
+
+  interface AxiosRequestTransformer {
+    (this: InternalAxiosRequestConfig, data: any, headers: AxiosRequestHeaders): any;
+  }
+
+  interface AxiosResponseTransformer {
+    (
+      this: InternalAxiosRequestConfig,
+      data: any,
+      headers: AxiosResponseHeaders,
+      status?: number
+    ): any;
+  }
+
+  interface AxiosAdapter {
+    (config: InternalAxiosRequestConfig): AxiosPromise;
+  }
+
+  interface AxiosBasicCredentials {
+    username: string;
+    password: string;
+  }
+
+  interface AxiosProxyConfig {
+    host: string;
+    port: number;
+    auth?: AxiosBasicCredentials;
+    protocol?: string;
+  }
+
+  type UppercaseMethod =
+    | 'GET'
+    | 'DELETE'
+    | 'HEAD'
+    | 'OPTIONS'
+    | 'POST'
+    | 'PUT'
+    | 'PATCH'
+    | 'PURGE'
+    | 'LINK'
+    | 'UNLINK'
+    | 'QUERY';
+
+  type Method = (UppercaseMethod | Lowercase<UppercaseMethod>) & {};
+
+  type ResponseType = 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream' | 'formdata';
+
+  type UppercaseResponseEncoding =
+    | 'ASCII'
+    | 'ANSI'
+    | 'BINARY'
+    | 'BASE64'
+    | 'BASE64URL'
+    | 'HEX'
+    | 'LATIN1'
+    | 'UCS-2'
+    | 'UCS2'
+    | 'UTF-8'
+    | 'UTF8'
+    | 'UTF16LE';
+
+  type responseEncoding = (UppercaseResponseEncoding | Lowercase<UppercaseResponseEncoding>) & {};
+
+  interface TransitionalOptions {
+    silentJSONParsing?: boolean;
+    forcedJSONParsing?: boolean;
+    clarifyTimeoutError?: boolean;
+    legacyInterceptorReqResOrdering?: boolean;
+    advertiseZstdAcceptEncoding?: boolean;
+    validateStatusUndefinedResolves?: boolean;
+  }
+
+  interface GenericAbortSignal {
+    readonly aborted: boolean;
+    onabort?: ((...args: any) => any) | null;
+    addEventListener?: (...args: any) => any;
+    removeEventListener?: (...args: any) => any;
+  }
+
+  interface FormDataVisitorHelpers {
+    defaultVisitor: SerializerVisitor;
+    convertValue: (value: any) => any;
+    isVisitable: (value: any) => boolean;
+  }
+
+  interface SerializerVisitor {
+    (
+      this: GenericFormData,
+      value: any,
+      key: string | number,
+      path: null | Array<string | number>,
+      helpers: FormDataVisitorHelpers
+    ): boolean;
+  }
+
+  interface SerializerOptions {
+    visitor?: SerializerVisitor;
+    dots?: boolean;
+    metaTokens?: boolean;
+    indexes?: boolean | null;
+    maxDepth?: number;
+    Blob?: { new (...args: any[]): any };
+  }
+
+  // tslint:disable-next-line
+  interface FormSerializerOptions extends SerializerOptions {}
+
+  interface ParamEncoder {
+    (value: any, defaultEncoder: (value: any) => any): any;
+  }
+
+  interface CustomParamsSerializer<P = Record<string, any>> {
+    (params: P, options?: ParamsSerializerOptions<P>): string;
+  }
+
+  interface ParamsSerializerOptions<P = Record<string, any>> extends SerializerOptions {
+    encode?: ParamEncoder;
+    serialize?: CustomParamsSerializer<P>;
+  }
+
+  type MaxUploadRate = number;
+
+  type MaxDownloadRate = number;
+
+  interface AxiosProgressEvent {
+    loaded: number;
+    total?: number;
+    progress?: number;
+    bytes: number;
+    rate?: number;
+    estimated?: number;
+    upload?: boolean;
+    download?: boolean;
+    event?: BrowserProgressEvent;
+    lengthComputable: boolean;
+  }
+
+  type Milliseconds = number;
+
+  type AxiosAdapterName = 'fetch' | 'xhr' | 'http' | (string & {});
+
+  type AxiosAdapterConfig = AxiosAdapter | AxiosAdapterName;
+
+  type AddressFamily = 4 | 6 | undefined;
+
+  interface LookupAddressEntry {
+    address: string;
+    family?: AddressFamily;
+  }
+
+  type LookupAddress = string | LookupAddressEntry;
+
+  interface AxiosRequestConfig<D = any, P = any> {
+    url?: string;
+    method?: Method | string;
+    baseURL?: string;
+    allowAbsoluteUrls?: boolean;
+    transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];
+    transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[];
+    headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders;
+    params?: P;
+    paramsSerializer?:
+      | ParamsSerializerOptions<unknown extends P ? Record<string, any> : P>
+      | CustomParamsSerializer<unknown extends P ? Record<string, any> : P>;
+    data?: D;
+    timeout?: Milliseconds;
+    timeoutErrorMessage?: string;
+    withCredentials?: boolean;
+    adapter?: AxiosAdapterConfig | AxiosAdapterConfig[];
+    auth?: AxiosBasicCredentials;
+    responseType?: ResponseType;
+    responseEncoding?: responseEncoding | string;
+    xsrfCookieName?: string;
+    xsrfHeaderName?: string;
+    onUploadProgress?: (progressEvent: AxiosProgressEvent) => void;
+    onDownloadProgress?: (progressEvent: AxiosProgressEvent) => void;
+    maxContentLength?: number;
+    validateStatus?: ((status: number) => boolean) | null;
+    maxBodyLength?: number;
+    maxRedirects?: number;
+    maxRate?: number | [MaxUploadRate, MaxDownloadRate];
+    beforeRedirect?: (
+      options: Record<string, any>,
+      responseDetails: { headers: Record<string, string>; statusCode: HttpStatusCode },
+      requestDetails: { headers: Record<string, string>; url: string; method: string },
+    ) => void;
+    socketPath?: string | null;
+    allowedSocketPaths?: string | string[] | null;
+    transport?: any;
+    httpAgent?: any;
+    httpsAgent?: any;
+    proxy?: AxiosProxyConfig | false;
+    cancelToken?: CancelToken | undefined;
+    decompress?: boolean;
+    transitional?: TransitionalOptions;
+    signal?: GenericAbortSignal;
+    insecureHTTPParser?: boolean;
+    env?: {
+      FormData?: new (...args: any[]) => object;
+      fetch?: (input: URL | Request | string, init?: RequestInit) => Promise<Response>;
+      Request?: new (input: URL | Request | string, init?: RequestInit) => Request;
+      Response?: new (
+        body?: ArrayBuffer | ArrayBufferView | Blob | FormData | URLSearchParams | string | null,
+        init?: ResponseInit
+      ) => Response;
+    };
+    formSerializer?: FormSerializerOptions;
+    family?: AddressFamily;
+    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
+        >);
+    withXSRFToken?: boolean | ((config: InternalAxiosRequestConfig<D, P>) => boolean | undefined);
+    parseReviver?: (this: any, key: string, value: any, context?: { source?: string }) => any;
+    fetchOptions?:
+      | Omit<RequestInit, 'body' | 'headers' | 'method' | 'signal'>
+      | Record<string, any>;
+    httpVersion?: 1 | 2;
+    http2Options?: Record<string, any> & {
+      sessionTimeout?: number;
+    };
+    formDataHeaderPolicy?: 'legacy' | 'content-only';
+    redact?: string[];
+    sensitiveHeaders?: string[];
+  }
+
+  // Alias
+  type RawAxiosRequestConfig<D = any, P = any> = AxiosRequestConfig<D, P>;
+
+  interface InternalAxiosRequestConfig<D = any, P = any> extends AxiosRequestConfig<D, P> {
+    headers: AxiosRequestHeaders;
+  }
+
+  interface HeadersDefaults {
+    common: RawAxiosRequestHeaders;
+    delete: RawAxiosRequestHeaders;
+    get: RawAxiosRequestHeaders;
+    head: RawAxiosRequestHeaders;
+    post: RawAxiosRequestHeaders;
+    put: RawAxiosRequestHeaders;
+    patch: RawAxiosRequestHeaders;
+    options?: RawAxiosRequestHeaders;
+    purge?: RawAxiosRequestHeaders;
+    link?: RawAxiosRequestHeaders;
+    unlink?: RawAxiosRequestHeaders;
+    query?: RawAxiosRequestHeaders;
+  }
+
+  interface AxiosDefaults<D = any, P = any> extends Omit<AxiosRequestConfig<D, P>, 'headers'> {
+    headers: HeadersDefaults;
+  }
+
+  interface CreateAxiosDefaults<D = any, P = any> extends Omit<
+    AxiosRequestConfig<D, P>,
+    'headers'
+  > {
+    headers?: RawAxiosRequestHeaders | AxiosHeaders | Partial<HeadersDefaults>;
+  }
+
+  interface AxiosResponse<T = any, D = any, H = {}, P = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: (H & RawAxiosResponseHeaders) | AxiosResponseHeaders;
+    config: InternalAxiosRequestConfig<D, P>;
+    request?: any;
+  }
+
+  type AxiosPromise<T = any, D = any, P = any> = Promise<AxiosResponse<T, D, {}, P>>;
+
+  interface CancelStatic {
+    new (message?: string): Cancel;
+  }
+
+  interface Cancel {
+    message: string | undefined;
+  }
+
+  interface Canceler {
+    (message?: string, config?: AxiosRequestConfig, request?: any): void;
+  }
+
+  interface CancelTokenStatic {
+    new (executor: (cancel: Canceler) => void): CancelToken;
+    source(): CancelTokenSource;
+  }
+
+  interface CancelToken {
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+    subscribe(listener: (cancel: Cancel | any) => void): void;
+    unsubscribe(listener: (cancel: Cancel | any) => void): void;
+    toAbortSignal(): AbortSignal;
+  }
+
+  interface CancelTokenSource {
+    token: CancelToken;
+    cancel: Canceler;
+  }
+
+  interface AxiosInterceptorOptions {
+    synchronous?: boolean;
+    runWhen?: ((config: InternalAxiosRequestConfig) => boolean) | null;
+  }
+
+  type AxiosInterceptorFulfilled<T> = (value: T) => T | Promise<T>;
+  type AxiosInterceptorRejected = (error: any) => any;
+
+  type AxiosRequestInterceptorUse<T> = (
+    onFulfilled?: AxiosInterceptorFulfilled<T> | null,
+    onRejected?: AxiosInterceptorRejected | null,
+    options?: AxiosInterceptorOptions
+  ) => number;
+
+  type AxiosResponseInterceptorUse<T> = (
+    onFulfilled?: AxiosInterceptorFulfilled<T> | null,
+    onRejected?: AxiosInterceptorRejected | null
+  ) => number;
+
+  interface AxiosInterceptorHandler<T> {
+    fulfilled: AxiosInterceptorFulfilled<T>;
+    rejected?: AxiosInterceptorRejected;
+    synchronous: boolean;
+    runWhen?: ((config: InternalAxiosRequestConfig) => boolean) | null;
+  }
+
+  interface AxiosInterceptorManager<V> {
+    use: V extends AxiosResponse ? AxiosResponseInterceptorUse<V> : AxiosRequestInterceptorUse<V>;
+    eject(id: number): void;
+    clear(): void;
+    handlers?: Array<AxiosInterceptorHandler<V>>;
+  }
+
+  interface AxiosInstance extends Axios {
+    <T = any, R = AxiosResponseDefault, D = any, P = any>(
+      config: AxiosRequestConfig<D, P>
+    ): Promise<AxiosResponseResult<T, R, D, P>>;
+    <T = any, R = AxiosResponseDefault, D = any, P = any>(
+      url: string,
+      config?: AxiosRequestConfig<D, P>
+    ): Promise<AxiosResponseResult<T, R, D, P>>;
+
+    create(config?: CreateAxiosDefaults): AxiosInstance;
+    defaults: Omit<AxiosDefaults, 'headers'> & {
+      headers: HeadersDefaults & {
+        [key: string]: AxiosHeaderValue;
+      };
+    };
+  }
+
+  interface GenericFormData {
+    append(name: string, value: any, options?: any): any;
+  }
+
+  interface GenericHTMLFormElement {
+    name: string;
+    method: string;
+    submit(): void;
+  }
+
+  interface AxiosStatic extends AxiosInstance {
+    Cancel: typeof CanceledError;
+    CancelToken: CancelTokenStatic;
+    Axios: typeof Axios;
+    AxiosError: typeof AxiosError;
+    CanceledError: typeof CanceledError;
+    HttpStatusCode: typeof HttpStatusCode;
+    readonly VERSION: string;
+    isCancel<T = any, D = any, P = any>(value: any): value is CanceledError<T, D, P>;
+    all<T>(values: Array<T | Promise<T>>): Promise<T[]>;
+    spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
+    isAxiosError<T = any, D = any, P = any>(payload: any): payload is AxiosError<T, D, P>;
+    toFormData(
+      sourceObj: object,
+      targetFormData?: GenericFormData,
+      options?: FormSerializerOptions
+    ): GenericFormData;
+    formToJSON(form: GenericFormData | GenericHTMLFormElement): object;
+    getAdapter(adapters: AxiosAdapterConfig | AxiosAdapterConfig[] | undefined): AxiosAdapter;
+    AxiosHeaders: typeof AxiosHeaders;
+    mergeConfig<D = any, P = any>(
+      config1: AxiosRequestConfig<D, P>,
+      config2: AxiosRequestConfig<D, P>
+    ): AxiosRequestConfig<D, P>;
+  }
+}
+
+declare const axios: axios.AxiosStatic;
+
+export = axios;