You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
529 lines
17 KiB
529 lines
17 KiB
type AxiosHeaderValue = AxiosHeaders | string | string[] | number | boolean | null;
|
|
|
|
interface RawAxiosHeaders {
|
|
[key: string]: AxiosHeaderValue;
|
|
}
|
|
|
|
type MethodsHeaders = Partial<{
|
|
[Key in axios.Method as Lowercase<Key>]: AxiosHeaders;
|
|
} & {common: AxiosHeaders}>;
|
|
|
|
type AxiosHeaderMatcher = (this: AxiosHeaders, value: string, name: string, headers: RawAxiosHeaders) => boolean;
|
|
|
|
type CommonRequestHeadersList = 'Accept' | 'Content-Length' | 'User-Agent'| 'Content-Encoding' | 'Authorization';
|
|
|
|
type ContentType = 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';
|
|
|
|
declare class AxiosHeaders {
|
|
constructor(
|
|
headers?: RawAxiosHeaders | AxiosHeaders
|
|
);
|
|
|
|
[key: string]: any;
|
|
|
|
set(headerName?: string, value?: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
|
|
set(headers?: RawAxiosHeaders | AxiosHeaders, rewrite?: boolean): AxiosHeaders;
|
|
|
|
get(headerName: string, parser: RegExp): RegExpExecArray | null;
|
|
get(headerName: string, matcher?: true | AxiosHeaderMatcher): AxiosHeaderValue;
|
|
|
|
has(header: string, matcher?: true | AxiosHeaderMatcher): boolean;
|
|
|
|
delete(header: string | string[], matcher?: AxiosHeaderMatcher): boolean;
|
|
|
|
clear(matcher?: AxiosHeaderMatcher): boolean;
|
|
|
|
normalize(format: boolean): AxiosHeaders;
|
|
|
|
concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>): AxiosHeaders;
|
|
|
|
toJSON(asStrings?: boolean): RawAxiosHeaders;
|
|
|
|
static from(thing?: AxiosHeaders | RawAxiosHeaders | string): AxiosHeaders;
|
|
|
|
static accessor(header: string | string[]): AxiosHeaders;
|
|
|
|
static concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>): AxiosHeaders;
|
|
|
|
setContentType(value: ContentType, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
|
|
getContentType(parser?: RegExp): RegExpExecArray | null;
|
|
getContentType(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
|
|
hasContentType(matcher?: AxiosHeaderMatcher): boolean;
|
|
|
|
setContentLength(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
|
|
getContentLength(parser?: RegExp): RegExpExecArray | null;
|
|
getContentLength(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
|
|
hasContentLength(matcher?: AxiosHeaderMatcher): boolean;
|
|
|
|
setAccept(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
|
|
getAccept(parser?: RegExp): RegExpExecArray | null;
|
|
getAccept(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
|
|
hasAccept(matcher?: AxiosHeaderMatcher): boolean;
|
|
|
|
setUserAgent(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
|
|
getUserAgent(parser?: RegExp): RegExpExecArray | null;
|
|
getUserAgent(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
|
|
hasUserAgent(matcher?: AxiosHeaderMatcher): boolean;
|
|
|
|
setContentEncoding(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
|
|
getContentEncoding(parser?: RegExp): RegExpExecArray | null;
|
|
getContentEncoding(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
|
|
hasContentEncoding(matcher?: AxiosHeaderMatcher): boolean;
|
|
|
|
setAuthorization(value: AxiosHeaderValue, rewrite?: boolean | AxiosHeaderMatcher): AxiosHeaders;
|
|
getAuthorization(parser?: RegExp): RegExpExecArray | null;
|
|
getAuthorization(matcher?: AxiosHeaderMatcher): AxiosHeaderValue;
|
|
hasAuthorization(matcher?: AxiosHeaderMatcher): boolean;
|
|
|
|
[Symbol.iterator](): IterableIterator<[string, AxiosHeaderValue]>;
|
|
}
|
|
|
|
declare class AxiosError<T = unknown, D = any> extends Error {
|
|
constructor(
|
|
message?: string,
|
|
code?: string,
|
|
config?: axios.InternalAxiosRequestConfig<D>,
|
|
request?: any,
|
|
response?: axios.AxiosResponse<T, D>
|
|
);
|
|
|
|
config?: axios.InternalAxiosRequestConfig<D>;
|
|
code?: string;
|
|
request?: any;
|
|
response?: axios.AxiosResponse<T, D>;
|
|
isAxiosError: boolean;
|
|
status?: number;
|
|
toJSON: () => object;
|
|
cause?: Error;
|
|
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 ECONNABORTED = "ECONNABORTED";
|
|
static readonly ETIMEDOUT = "ETIMEDOUT";
|
|
}
|
|
|
|
declare class CanceledError<T> extends AxiosError<T> {
|
|
}
|
|
|
|
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 = axios.AxiosResponse<T>, D = any>(config: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
get<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
delete<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
head<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
options<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
post<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
put<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
patch<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
postForm<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
putForm<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
patchForm<T = any, R = axios.AxiosResponse<T>, D = any>(url: string, data?: D, config?: axios.AxiosRequestConfig<D>): Promise<R>;
|
|
}
|
|
|
|
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,
|
|
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,
|
|
}
|
|
|
|
type InternalAxiosError<T = unknown, D = any> = AxiosError<T, D>;
|
|
|
|
declare namespace axios {
|
|
type AxiosError<T = unknown, D = any> = InternalAxiosError<T, D>;
|
|
|
|
type RawAxiosRequestHeaders = Partial<RawAxiosHeaders & {
|
|
[Key in CommonRequestHeadersList]: AxiosHeaderValue;
|
|
} & {
|
|
'Content-Type': ContentType
|
|
}>;
|
|
|
|
type AxiosRequestHeaders = RawAxiosRequestHeaders & AxiosHeaders;
|
|
|
|
type RawCommonResponseHeaders = {
|
|
[Key in CommonResponseHeadersList]: 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?: {
|
|
username: string;
|
|
password: string;
|
|
};
|
|
protocol?: string;
|
|
}
|
|
|
|
type Method =
|
|
| 'get' | 'GET'
|
|
| 'delete' | 'DELETE'
|
|
| 'head' | 'HEAD'
|
|
| 'options' | 'OPTIONS'
|
|
| 'post' | 'POST'
|
|
| 'put' | 'PUT'
|
|
| 'patch' | 'PATCH'
|
|
| 'purge' | 'PURGE'
|
|
| 'link' | 'LINK'
|
|
| 'unlink' | 'UNLINK';
|
|
|
|
type ResponseType =
|
|
| 'arraybuffer'
|
|
| 'blob'
|
|
| 'document'
|
|
| 'json'
|
|
| 'text'
|
|
| 'stream';
|
|
|
|
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';
|
|
|
|
interface TransitionalOptions {
|
|
silentJSONParsing?: boolean;
|
|
forcedJSONParsing?: boolean;
|
|
clarifyTimeoutError?: 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;
|
|
}
|
|
|
|
// tslint:disable-next-line
|
|
interface FormSerializerOptions extends SerializerOptions {
|
|
}
|
|
|
|
interface ParamEncoder {
|
|
(value: any, defaultEncoder: (value: any) => any): any;
|
|
}
|
|
|
|
interface CustomParamsSerializer {
|
|
(params: Record<string, any>, options?: ParamsSerializerOptions): string;
|
|
}
|
|
|
|
interface ParamsSerializerOptions extends SerializerOptions {
|
|
encode?: ParamEncoder;
|
|
serialize?: CustomParamsSerializer;
|
|
}
|
|
|
|
type MaxUploadRate = number;
|
|
|
|
type MaxDownloadRate = number;
|
|
|
|
type BrowserProgressEvent = any;
|
|
|
|
interface AxiosProgressEvent {
|
|
loaded: number;
|
|
total?: number;
|
|
progress?: number;
|
|
bytes: number;
|
|
rate?: number;
|
|
estimated?: number;
|
|
upload?: boolean;
|
|
download?: boolean;
|
|
event?: BrowserProgressEvent;
|
|
}
|
|
|
|
type Milliseconds = number;
|
|
|
|
type AxiosAdapterName = 'xhr' | 'http' | string;
|
|
|
|
type AxiosAdapterConfig = AxiosAdapter | AxiosAdapterName;
|
|
|
|
interface AxiosRequestConfig<D = any> {
|
|
url?: string;
|
|
method?: Method | string;
|
|
baseURL?: string;
|
|
transformRequest?: AxiosRequestTransformer | AxiosRequestTransformer[];
|
|
transformResponse?: AxiosResponseTransformer | AxiosResponseTransformer[];
|
|
headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders;
|
|
params?: any;
|
|
paramsSerializer?: ParamsSerializerOptions;
|
|
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>}) => void;
|
|
socketPath?: string | null;
|
|
httpAgent?: any;
|
|
httpsAgent?: any;
|
|
proxy?: AxiosProxyConfig | false;
|
|
cancelToken?: CancelToken;
|
|
decompress?: boolean;
|
|
transitional?: TransitionalOptions;
|
|
signal?: GenericAbortSignal;
|
|
insecureHTTPParser?: boolean;
|
|
env?: {
|
|
FormData?: new (...args: any[]) => object;
|
|
};
|
|
formSerializer?: FormSerializerOptions;
|
|
}
|
|
|
|
// Alias
|
|
type RawAxiosRequestConfig<D = any> = AxiosRequestConfig<D>;
|
|
|
|
interface InternalAxiosRequestConfig<D = any> extends AxiosRequestConfig {
|
|
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;
|
|
}
|
|
|
|
interface AxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
|
|
headers: HeadersDefaults;
|
|
}
|
|
|
|
interface CreateAxiosDefaults<D = any> extends Omit<AxiosRequestConfig<D>, 'headers'> {
|
|
headers?: RawAxiosRequestHeaders | AxiosHeaders | Partial<HeadersDefaults>;
|
|
}
|
|
|
|
interface AxiosResponse<T = any, D = any> {
|
|
data: T;
|
|
status: number;
|
|
statusText: string;
|
|
headers: RawAxiosResponseHeaders | AxiosResponseHeaders;
|
|
config: InternalAxiosRequestConfig<D>;
|
|
request?: any;
|
|
}
|
|
|
|
type AxiosPromise<T = any> = Promise<AxiosResponse<T>>;
|
|
|
|
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;
|
|
}
|
|
|
|
interface CancelTokenSource {
|
|
token: CancelToken;
|
|
cancel: Canceler;
|
|
}
|
|
|
|
interface AxiosInterceptorOptions {
|
|
synchronous?: boolean;
|
|
runWhen?: (config: InternalAxiosRequestConfig) => boolean;
|
|
}
|
|
|
|
interface AxiosInterceptorManager<V> {
|
|
use(onFulfilled?: (value: V) => V | Promise<V>, onRejected?: (error: any) => any, options?: AxiosInterceptorOptions): number;
|
|
eject(id: number): void;
|
|
clear(): void;
|
|
}
|
|
|
|
interface AxiosInstance extends Axios {
|
|
<T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
|
|
<T = any, R = AxiosResponse<T>, D = any>(url: string, config?: AxiosRequestConfig<D>): Promise<R>;
|
|
|
|
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 {
|
|
create(config?: CreateAxiosDefaults): AxiosInstance;
|
|
Cancel: CancelStatic;
|
|
CancelToken: CancelTokenStatic;
|
|
Axios: typeof Axios;
|
|
AxiosError: typeof AxiosError;
|
|
CanceledError: typeof CanceledError;
|
|
HttpStatusCode: typeof HttpStatusCode;
|
|
readonly VERSION: string;
|
|
isCancel(value: any): value is Cancel;
|
|
all<T>(values: Array<T | Promise<T>>): Promise<T[]>;
|
|
spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
|
|
isAxiosError<T = any, D = any>(payload: any): payload is AxiosError<T, D>;
|
|
toFormData(sourceObj: object, targetFormData?: GenericFormData, options?: FormSerializerOptions): GenericFormData;
|
|
formToJSON(form: GenericFormData|GenericHTMLFormElement): object;
|
|
AxiosHeaders: typeof AxiosHeaders;
|
|
}
|
|
}
|
|
|
|
declare const axios: axios.AxiosStatic;
|
|
|
|
export = axios;
|