got

constructor

constructor(request: Request);

constructor

constructor(error: NodeJS.ErrnoException, request: Request);

property request

readonly request: Request;

constructor

constructor(request: Request);

property isCanceled

readonly isCanceled: boolean;

• Whether the promise is canceled.

property response

readonly response: any;

constructor

constructor(response: any);

property request

readonly request: Request;

property response

readonly response: any;

property timings

readonly timings: Timings;

constructor

constructor(request: Request);

property request

readonly request: Request;

property response

readonly response: any;

property timings

readonly timings: Timings;

constructor

constructor(
    input?: string | OptionsInit | URL,
    options?: OptionsInit,
    defaults?: Options
);

property agent

agent: Agents;

• An object representing http, https and http2 keys for [http.Agent](https://nodejs.org/api/http.html#http_class_http_agent), [https.Agent](https://nodejs.org/api/https.html#https_class_https_agent) and [http2wrapper.Agent](https://github.com/szmarczak/http2-wrapper#new-http2agentoptions) instance. This is necessary because a request to one protocol might redirect to another. In such a scenario, Got will switch over to the right protocol agent for you.

  If a key is not present, it will default to a global agent.

  Example 1

  ``` import got from 'got'; import HttpAgent from 'agentkeepalive';

  const {HttpsAgent} = HttpAgent;

  await got('https://sindresorhus.com', { agent: { http: new HttpAgent(), https: new HttpsAgent() } }); ```

property allowGetBody

allowGetBody: boolean;

• Set this to true to allow sending body for the GET method. However, the [HTTP/2 specification](https://tools.ietf.org/html/rfc7540#section-8.1.3) says that An HTTP GET request includes request header fields and no payload body, therefore when using the HTTP/2 protocol this option will have no effect. This option is only meant to interact with non-compliant servers when you have no other choice.

  __Note__: The [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.1) doesn't specify any particular behavior for the GET method having a payload, therefore __it's considered an [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern)__.

  false

property auth

auth: {};

property body

body: any;

• __Note #1__: The body option cannot be used with the json or form option.

  __Note #2__: If you provide this option, got.stream() will be read-only.

  __Note #3__: If you provide a payload with the GET or HEAD method, it will throw a TypeError unless the method is GET and the allowGetBody option is set to true.

  __Note #4__: This option is not enumerable and will not be merged with the instance defaults.

  The content-length header will be automatically set if body is a string / Buffer / [FormData](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [form-data instance](https://github.com/form-data/form-data), and content-length and transfer-encoding are not manually set in options.headers.

  Since Got 12, the content-length is not automatically set when body is a fs.createReadStream.

property cache

cache: any;

• A cache adapter instance for storing cached response data.

  false

property cacheOptions

cacheOptions: CacheOptions;

• From http-cache-semantics

  {}

property context

context: Record<string, unknown>;

• User data. context is shallow merged and enumerable. If it contains non-enumerable properties they will NOT be merged.

  Example 1

  ``` import got from 'got';

  const instance = got.extend({ hooks: { beforeRequest: [ options => { if (!options.context || !options.context.token) { throw new Error('Token required'); }

  options.headers.token = options.context.token; } ] } });

  const context = { token: 'secret' };

  const response = await instance('https://httpbin.org/headers', {context});

  // Let's see the headers console.log(response.body); ```

property cookieJar

cookieJar: PromiseCookieJar | ToughCookieJar;

• Cookie support. You don't have to care about parsing or how to store them.

  __Note__: If you provide this option, options.headers.cookie will be overridden.

property createConnection

createConnection: CreateConnectionFunction;

property decompress

decompress: boolean;

• Decompress the response automatically.

  This will set the accept-encoding header to gzip, deflate, br unless you set it yourself.

  If this is disabled, a compressed response is returned as a Buffer. This may be useful if you want to handle decompression yourself or stream the raw compressed data.

  true

property dnsCache

dnsCache: any;

• An instance of [CacheableLookup](https://github.com/szmarczak/cacheable-lookup) used for making DNS lookups. Useful when making lots of requests to different *public* hostnames.

  CacheableLookup uses dns.resolver4(..) and dns.resolver6(...) under the hood and fall backs to dns.lookup(...) when the first two fail, which may lead to additional delay.

  __Note__: This should stay disabled when making requests to internal hostnames such as localhost, database.local etc.

  false

property dnsLookup

dnsLookup: any;

property dnsLookupIpVersion

dnsLookupIpVersion: DnsLookupIpVersion;

• Indicates which DNS record family to use.

  Values: - undefined: IPv4 (if present) or IPv6 - 4: Only IPv4 - 6: Only IPv6

  undefined

property enableUnixSockets

enableUnixSockets: boolean;

property encoding

encoding: any;

• [Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on setEncoding of the response data.

  To get a [Buffer](https://nodejs.org/api/buffer.html), you need to set responseType to buffer instead. Don't set this option to null.

  __Note__: This doesn't affect streams! Instead, you need to do got.stream(...).setEncoding(encoding).

  'utf-8'

property followRedirect

followRedirect: boolean | ((response: PlainResponse) => boolean);

• Whether redirect responses should be followed automatically.

  Optionally, pass a function to dynamically decide based on the response object.

  Note that if a 303 is sent by the server in response to any request type (POST, DELETE, etc.), Got will automatically request the resource pointed to in the location header via GET. This is in accordance with [the spec](https://tools.ietf.org/html/rfc7231#section-6.4.4). You can optionally turn on this behavior also for other redirect codes - see methodRewriting.

  true

property followRedirects

followRedirects: {};

property form

form: Record<string, any>;

• The form body is converted to a query string using [(new URLSearchParams(object)).toString()](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).

  If the Content-Type header is not present, it will be set to application/x-www-form-urlencoded.

  __Note #1__: If you provide this option, got.stream() will be read-only.

  __Note #2__: This option is not enumerable and will not be merged with the instance defaults.

property h2session

h2session: any;

property headers

headers: Headers;

• Request headers.

  Existing headers will be overwritten. Headers set to undefined will be omitted.

  {}

property hooks

hooks: Hooks;

• Hooks allow modifications during the request lifecycle. Hook functions may be async and are run serially.

property http2

http2: boolean;

• If set to true, Got will additionally accept HTTP2 requests.

  It will choose either HTTP/1.1 or HTTP/2 depending on the ALPN protocol.

  __Note__: This option requires Node.js 15.10.0 or newer as HTTP/2 support on older Node.js versions is very buggy.

  __Note__: Overriding options.request will disable HTTP2 support.

  false

  Example 1

  ``` import got from 'got';

  const {headers} = await got('https://nghttp2.org/httpbin/anything', {http2: true});

  console.log(headers.via); //=> '2 nghttpx' ```

property https

https: HttpsOptions;

• Options for the advanced HTTPS API.

property ignoreInvalidCookies

ignoreInvalidCookies: boolean;

• Ignore invalid cookies instead of throwing an error. Only useful when the cookieJar option has been set. Not recommended.

  false

property isStream

isStream: boolean;

• Returns a Stream instead of a Promise. This is equivalent to calling got.stream(url, options?).

  false

property json

json: {};

• JSON body. If the Content-Type header is not set, it will be set to application/json.

  __Note #1__: If you provide this option, got.stream() will be read-only.

  __Note #2__: This option is not enumerable and will not be merged with the instance defaults.

property localAddress

localAddress: string;

• From http.RequestOptions.

  The IP address used to send the request from.

property maxHeaderSize

maxHeaderSize: number;

property maxRedirects

maxRedirects: number;

• If exceeded, the request will be aborted and a MaxRedirectsError will be thrown.

  10

property method

method: Method;

• The HTTP method used to make the request.

  'GET'

property methodRewriting

methodRewriting: boolean;

• Specifies if the HTTP request method should be [rewritten as GET](https://tools.ietf.org/html/rfc7231#section-6.4) on redirects.

  As the [specification](https://tools.ietf.org/html/rfc7231#section-6.4) prefers to rewrite the HTTP method only on 303 responses, this is Got's default behavior. Setting methodRewriting to true will also rewrite 301 and 302 responses, as allowed by the spec. This is the behavior followed by curl and browsers.

  __Note__: Got never performs method rewriting on 307 and 308 responses, as this is [explicitly prohibited by the specification](https://www.rfc-editor.org/rfc/rfc7231#section-6.4.7).

  false

property pagination

pagination: PaginationOptions<unknown, unknown>;

property parseJson

parseJson: ParseJsonFunction;

• A function used to parse JSON responses.

  Example 1

  ``` import got from 'got'; import Bourne from '@hapi/bourne';

  const parsed = await got('https://example.com', { parseJson: text => Bourne.parse(text) }).json();

  console.log(parsed); ```

property password

password: string;

property prefixUrl

prefixUrl: string | URL;

• When specified, prefixUrl will be prepended to url. The prefix can be any valid URL, either relative or absolute. A trailing slash / is optional - one will be added automatically.

  __Note__: prefixUrl will be ignored if the url argument is a URL instance.

  __Note__: Leading slashes in input are disallowed when using this option to enforce consistency and avoid confusion. For example, when the prefix URL is https://example.com/foo and the input is /bar, there's ambiguity whether the resulting URL would become https://example.com/foo/bar or https://example.com/bar. The latter is used by browsers.

  __Tip__: Useful when used with got.extend() to create niche-specific Got instances.

  __Tip__: You can change prefixUrl using hooks as long as the URL still includes the prefixUrl. If the URL doesn't include it anymore, it will throw.

  Example 1

  ``` import got from 'got';

  await got('unicorn', {prefixUrl: 'https://cats.com'}); //=> 'https://cats.com/unicorn'

  const instance = got.extend({ prefixUrl: 'https://google.com' });

  await instance('unicorn', { hooks: { beforeRequest: [ options => { options.prefixUrl = 'https://cats.com'; } ] } }); //=> 'https://cats.com/unicorn' ```

property request

request: RequestFunction;

• Custom request function. The main purpose of this is to [support HTTP2 using a wrapper](https://github.com/szmarczak/http2-wrapper).

  http.request | https.request

property resolveBodyOnly

resolveBodyOnly: boolean;

• When set to true the promise will return the Response body instead of the Response object.

  false

property responseType

responseType: ResponseType;

• The parsing method.

  The promise also has .text(), .json() and .buffer() methods which return another Got promise for the parsed body.

  It's like setting the options to {responseType: 'json', resolveBodyOnly: true} but without affecting the main Got promise.

  __Note__: When using streams, this option is ignored.

  Example 1

  ``` const responsePromise = got(url); const bufferPromise = responsePromise.buffer(); const jsonPromise = responsePromise.json();

  const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]); // response is an instance of Got Response // buffer is an instance of Buffer // json is an object ```

  Example 2

  ``` // This const body = await got(url).json();

  // is semantically the same as this const body = await got(url, {responseType: 'json', resolveBodyOnly: true}); ```

property retry

retry: Partial<RetryOptions>;

• An object representing limit, calculateDelay, methods, statusCodes, maxRetryAfter and errorCodes fields for maximum retry count, retry handler, allowed methods, allowed status codes, maximum [Retry-After](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) time and allowed error codes.

  Delays between retries counts with function 1000 * Math.pow(2, retry) + Math.random() * 100, where retry is attempt number (starts from 1).

  The calculateDelay property is a function that receives an object with attemptCount, retryOptions, error and computedValue properties for current retry count, the retry options, error and default computed value. The function must return a delay in milliseconds (or a Promise resolving with it) (0 return value cancels retry).

  By default, it retries *only* on the specified methods, status codes, and on these network errors:

  - ETIMEDOUT: One of the [timeout](#timeout) limits were reached. - ECONNRESET: Connection was forcibly closed by a peer. - EADDRINUSE: Could not bind to any free port. - ECONNREFUSED: Connection was refused by the server. - EPIPE: The remote side of the stream being written has been closed. - ENOTFOUND: Couldn't resolve the hostname to an IP address. - ENETUNREACH: No internet connection. - EAI_AGAIN: DNS lookup timed out.

  __Note__: If maxRetryAfter is set to undefined, it will use options.timeout. __Note__: If [Retry-After](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After) header is greater than maxRetryAfter, it will cancel the request.

property searchParameters

searchParameters: {};

property searchParams

searchParams: string | SearchParameters | URLSearchParams;

• Query string that will be added to the request URL. This will override the query string in url.

  If you need to pass in an array, you can do it using a URLSearchParams instance.

  Example 1

  ``` import got from 'got';

  const searchParams = new URLSearchParams([['key', 'a'], ['key', 'b']]);

  await got('https://example.com', {searchParams});

  console.log(searchParams.toString()); //=> 'key=a&key=b' ```

property setHost

setHost: boolean;

property signal

signal: AbortSignal;

• You can abort the request using [AbortController](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).

  Example 1

  ``` import got from 'got';

  const abortController = new AbortController();

  const request = got('https://httpbin.org/anything', { signal: abortController.signal });

  setTimeout(() => { abortController.abort(); }, 100); ```

property stringifyJson

stringifyJson: StringifyJsonFunction;

• A function used to stringify the body of JSON requests.

  Example 1

  ``` import got from 'got';

  await got.post('https://example.com', { stringifyJson: object => JSON.stringify(object, (key, value) => { if (key.startsWith('_')) { return; }

  return value; }), json: { some: 'payload', _ignoreMe: 1234 } }); ```

  Example 2

  ``` import got from 'got';

  await got.post('https://example.com', { stringifyJson: object => JSON.stringify(object, (key, value) => { if (typeof value === 'number') { return value.toString(); }

  return value; }), json: { some: 'payload', number: 1 } }); ```

property throwHttpErrors

throwHttpErrors: boolean;

• Determines if a got.HTTPError is thrown for unsuccessful responses.

  If this is disabled, requests that encounter an error status code will be resolved with the response instead of throwing. This may be useful if you are checking for resource availability and are expecting error responses.

  true

property timeout

timeout: Delays;

• Milliseconds to wait for the server to end the response before aborting the request with got.TimeoutError error (a.k.a. request property). By default, there's no timeout.

  This also accepts an object with the following fields to constrain the duration of each phase of the request lifecycle:

  - lookup starts when a socket is assigned and ends when the hostname has been resolved. Does not apply when using a Unix domain socket. - connect starts when lookup completes (or when the socket is assigned if lookup does not apply to the request) and ends when the socket is connected. - secureConnect starts when connect completes and ends when the handshaking process completes (HTTPS only). - socket starts when the socket is connected. See [request.setTimeout](https://nodejs.org/api/http.html#http_request_settimeout_timeout_callback). - response starts when the request has been written to the socket and ends when the response headers are received. - send starts when the socket is connected and ends with the request has been written to the socket. - request starts when the request is initiated and ends when the response's end event fires.

property url

url: string | URL;

• The URL to request, as a string, a [https.request options object](https://nodejs.org/api/https.html#https_https_request_options_callback), or a [WHATWG URL](https://nodejs.org/api/url.html#url_class_url).

  Properties from options will override properties in the parsed url.

  If no protocol is specified, it will throw a TypeError.

  __Note__: The query string is **not** parsed as search params.

  Example 1

  ``` await got('https://example.com/?query=a b'); //=> https://example.com/?query=a%20b await got('https://example.com/', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b

  // The query string is overridden by searchParams await got('https://example.com/?query=a b', {searchParams: {query: 'a b'}}); //=> https://example.com/?query=a+b ```

property username

username: string;

method createNativeRequestOptions

createNativeRequestOptions: () => {
    ALPNProtocols: string[] | undefined;
    ca: string | Buffer | (string | Buffer)[] | undefined;
    cert: string | Buffer | (string | Buffer)[] | undefined;
    key:
        | string
        | Buffer
        | (string | Buffer | import('tls').KeyObject)[]
        | undefined;
    passphrase: string | undefined;
    pfx: PfxType;
    rejectUnauthorized: boolean | undefined;
    checkServerIdentity:
        | typeof checkServerIdentity
        | CheckServerIdentityFunction;
    ciphers: string | undefined;
    honorCipherOrder: boolean | undefined;
    minVersion: import('tls').SecureVersion | undefined;
    maxVersion: import('tls').SecureVersion | undefined;
    sigalgs: string | undefined;
    sessionTimeout: number | undefined;
    dhparam: string | Buffer | undefined;
    ecdhCurve: string | undefined;
    crl: string | Buffer | (string | Buffer)[] | undefined;
    lookup: {
        (
            hostname: string,
            family: any,
            callback: (
                error: NodeJS.ErrnoException | null,
                address: string,
                family: any
            ) => void
        ): void;
        (
            hostname: string,
            callback: (
                error: NodeJS.ErrnoException | null,
                address: string,
                family: any
            ) => void
        ): void;
        (
            hostname: string,
            options: import('cacheable-lookup').LookupOptions & { all: true },
            callback: (
                error: NodeJS.ErrnoException | null,
                result: ReadonlyArray<import('cacheable-lookup').EntryObject>
            ) => void
        ): void;
        (
            hostname: string,
            options: any,
            callback: (
                error: NodeJS.ErrnoException | null,
                address: string,
                family: any
            ) => void
        ): void;
    };
    family: DnsLookupIpVersion;
    agent: false | http.Agent | Agents | undefined;
    setHost: boolean;
    method: Method;
    maxHeaderSize: number | undefined;
    localAddress: string | undefined;
    headers: Headers;
    createConnection: CreateConnectionFunction | undefined;
    timeout: number | undefined;
    h2session: http2wrapper.ClientHttp2Session | undefined;
    _defaultAgent?: http.Agent | undefined;
    auth?: string | null | undefined;
    defaultPort?: number | string | undefined;
    hints?: any;
    host?: string | null | undefined;
    hostname?: string | null | undefined;
    insecureHTTPParser?: boolean | undefined;
    localPort?: number | undefined;
    path?: string | null | undefined;
    port?: number | string | null | undefined;
    protocol?: string | null | undefined;
    signal?: AbortSignal | undefined;
    socketPath?: string | undefined;
    uniqueHeaders?: Array<string | string[]> | undefined;
    joinDuplicateHeaders?: boolean;
    ALPNCallback?: (arg: {
        servername: string;
        protocols: string[];
    }) => string | undefined;
    clientCertEngine?: string | undefined;
    privateKeyEngine?: string | undefined;
    privateKeyIdentifier?: string | undefined;
    secureOptions?: number | undefined;
    secureProtocol?: string | undefined;
    sessionIdContext?: string | undefined;
    ticketKeys?: Buffer | undefined;
    servername?: string | undefined;
    shared?: boolean;
    cacheHeuristic?: number;
    immutableMinTimeToLive?: number;
    ignoreCargoCult?: boolean;
};

method freeze

freeze: () => void;

method getFallbackRequestFunction

getFallbackRequestFunction: () =>
    | RequestFunction
    | typeof https.request
    | undefined;

method getRequestFunction

getRequestFunction: () => RequestFunction | typeof https.request | undefined;

method merge

merge: (options?: OptionsInit | Options) => void;

method toJSON

toJSON: () => {
    headers: Headers;
    timeout: Delays;
    request: RequestFunction | undefined;
    username: string;
    password: string;
    json: unknown;
    followRedirect: boolean | ((response: PlainResponse) => boolean);
    retry: Partial<RetryOptions>;
    agent: Agents;
    h2session: http2wrapper.ClientHttp2Session | undefined;
    decompress: boolean;
    prefixUrl: string | URL;
    body:
        | string
        | Readable
        | Buffer
        | Generator<unknown, any, any>
        | AsyncGenerator<unknown, any, any>
        | FormDataLike
        | undefined;
    form: Record<string, any> | undefined;
    url: string | URL | undefined;
    cookieJar: PromiseCookieJar | ToughCookieJar | undefined;
    signal: AbortSignal | undefined;
    ignoreInvalidCookies: boolean;
    searchParams: string | URLSearchParams | SearchParameters | undefined;
    dnsLookup: {
        (
            hostname: string,
            family: any,
            callback: (
                error: NodeJS.ErrnoException | null,
                address: string,
                family: any
            ) => void
        ): void;
        (
            hostname: string,
            callback: (
                error: NodeJS.ErrnoException | null,
                address: string,
                family: any
            ) => void
        ): void;
        (
            hostname: string,
            options: import('cacheable-lookup').LookupOptions & { all: true },
            callback: (
                error: NodeJS.ErrnoException | null,
                result: ReadonlyArray<import('cacheable-lookup').EntryObject>
            ) => void
        ): void;
        (
            hostname: string,
            options: any,
            callback: (
                error: NodeJS.ErrnoException | null,
                address: string,
                family: any
            ) => void
        ): void;
    };
    dnsCache: boolean | CacheableLookup | undefined;
    context: Record<string, unknown>;
    hooks: Hooks;
    maxRedirects: number;
    cache: string | boolean | StorageAdapter | undefined;
    throwHttpErrors: boolean;
    http2: boolean;
    allowGetBody: boolean;
    methodRewriting: boolean;
    dnsLookupIpVersion: DnsLookupIpVersion;
    parseJson: ParseJsonFunction;
    stringifyJson: StringifyJsonFunction;
    localAddress: string | undefined;
    method: Method;
    createConnection: CreateConnectionFunction | undefined;
    cacheOptions: CacheOptions;
    https: HttpsOptions;
    encoding: BufferEncoding | undefined;
    resolveBodyOnly: boolean;
    isStream: boolean;
    responseType: ResponseType;
    pagination: PaginationOptions<unknown, unknown>;
    setHost: boolean;
    maxHeaderSize: number | undefined;
    enableUnixSockets: boolean;
};

constructor

constructor(error: Error, response: any);

property response

readonly response: any;

constructor

constructor(error: NodeJS.ErrnoException, request: Request);

property request

readonly request: Request;

property response

readonly response: any;

property timings

readonly timings: Timings;

constructor

constructor(
    url: string | OptionsInit | URL,
    options?: OptionsInit,
    defaults?: Options
);

property ['constructor']

['constructor']: typeof Request;

property downloadProgress

readonly downloadProgress: Progress;

• Progress event for downloading (receiving a response).

property ip

readonly ip: string;

• The remote IP address.

property isAborted

readonly isAborted: boolean;

• Indicates whether the request has been aborted or not.

property isFromCache

readonly isFromCache: boolean;

• Whether the response was retrieved from the cache.

property options

options: Options;

property redirectUrls

redirectUrls: URL[];

property requestUrl

requestUrl?: URL;

property response

response?: any;

property retryCount

retryCount: number;

property reusedSocket

readonly reusedSocket: boolean;

property socket

readonly socket: any;

property timings

readonly timings: any;

• The object contains the following properties:

  - start - Time when the request started. - socket - Time when a socket was assigned to the request. - lookup - Time when the DNS lookup finished. - connect - Time when the socket successfully connected. - secureConnect - Time when the socket securely connected. - upload - Time when the request finished uploading. - response - Time when the request fired response event. - end - Time when the response fired end event. - error - Time when the request fired error event. - abort - Time when the request fired abort event. - phases - wait - timings.socket - timings.start - dns - timings.lookup - timings.socket - tcp - timings.connect - timings.lookup - tls - timings.secureConnect - timings.connect - request - timings.upload - (timings.secureConnect || timings.connect) - firstByte - timings.response - timings.upload - download - timings.end - timings.response - total - (timings.end || timings.error || timings.abort) - timings.start

  If something has not been measured yet, it will be undefined.

  __Note__: The time is a number representing the milliseconds elapsed since the UNIX epoch.

property uploadProgress

readonly uploadProgress: Progress;

• Progress event for uploading (sending a request).

method flush

flush: () => Promise<void>;

method pipe

pipe: <T extends NodeJS.WritableStream>(
    destination: T,
    options?: { end?: boolean }
) => T;

method unpipe

unpipe: <T extends NodeJS.WritableStream>(destination: T) => this;

constructor

constructor(message: string, error: Partial<any>, self: Options | Request);

property code

code: string;

property input

input?: string;

property options

readonly options: Options;

property request

readonly request?: Request;

property response

readonly response?: any;

property stack

stack: string;

property timings

readonly timings?: Timings;

constructor

constructor(request: Request);

constructor

constructor(error: TimedOutTimeoutError, timings: Timings, request: Request);

property event

readonly event: string;

property request

readonly request: Request;

property timings

readonly timings: Timings;

constructor

constructor(error: NodeJS.ErrnoException, request: Request);

property request

readonly request: Request;

property buffer

buffer: () => CancelableRequest<Buffer>;

• A shortcut method that gives a Promise returning a [Buffer](https://nodejs.org/api/buffer.html).

  It is semantically the same as settings options.resolveBodyOnly to true and options.responseType to 'buffer'.

property json

json: <ReturnType>() => CancelableRequest<ReturnType>;

• A shortcut method that gives a Promise returning a JSON object.

  It is semantically the same as settings options.resolveBodyOnly to true and options.responseType to 'json'.

property text

text: () => CancelableRequest<string>;

• A shortcut method that gives a Promise returning a string.

  It is semantically the same as settings options.resolveBodyOnly to true and options.responseType to 'text'.