got 12.0.0-beta.4 → 12.0.2

package/dist/source/as-promise/index.d.ts

@@ -1,3 +1,3 @@
 import Request from '../core/index.js';
 import type { CancelableRequest } from './types.js';
-export default function asPromise<T>(firstRequest: Request): CancelableRequest<T>;
+export default function asPromise<T>(firstRequest?: Request): CancelableRequest<T>;

package/dist/source/as-promise/index.js

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 import is from '@sindresorhus/is';
 import PCancelable from 'p-cancelable';
 import { HTTPError, RetryError, } from '../core/errors.js';
@@ -38,7 +38,7 @@ export default function asPromise(firstRequest) {
             request.once('response', async (response) => {
                 // Parse body
                 const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
-                const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'defalte' || contentEncoding === 'br';
+                const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br';
                 const { options } = request;
                 if (isCompressed && !options.decompress) {
                     response.body = response.rawBody;
@@ -48,7 +48,7 @@ export default function asPromise(firstRequest) {
                         response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
                     }
                     catch (error) {
-                        // Fallback to `utf8`
+                        // Fall back to `utf8`
                         response.body = response.rawBody.toString();
                         if (isResponseOk(response)) {
                             request._beforeError(error);
@@ -58,10 +58,7 @@ export default function asPromise(firstRequest) {
                 }
                 try {
                     const hooks = options.hooks.afterResponse;
-                    // TODO: `xo` should detect if `index` is being used for something else
-                    // eslint-disable-next-line unicorn/no-for-loop
-                    for (let index = 0; index < hooks.length; index++) {
-                        const hook = hooks[index];
+                    for (const [index, hook] of hooks.entries()) {
                         // @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
                         // eslint-disable-next-line no-await-in-loop
                         response = await hook(response, async (updatedOptions) => {
@@ -108,7 +105,6 @@ export default function asPromise(firstRequest) {
             request.once('error', onError);
             const previousBody = request.options?.body;
             request.once('retry', (newRetryCount, error) => {
-                // @ts-expect-error
                 firstRequest = undefined;
                 const newBody = request.options.body;
                 if (previousBody === newBody && is.nodeStream(newBody)) {

package/dist/source/as-promise/types.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import type { Buffer } from 'node:buffer';
 import PCancelable from 'p-cancelable';
 import { RequestError } from '../core/errors.js';
 import type Request from '../core/index.js';
@@ -10,10 +11,28 @@ An error to be thrown when the request is aborted with `.cancel()`.
 export declare class CancelError extends RequestError {
     readonly response: Response;
     constructor(request: Request);
+    /**
+    Whether the promise is canceled.
+    */
     get isCanceled(): boolean;
 }
 export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
+    /**
+    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'`.
+    */
     json: <ReturnType>() => CancelableRequest<ReturnType>;
+    /**
+    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'`.
+    */
     buffer: () => CancelableRequest<Buffer>;
+    /**
+    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'`.
+    */
     text: () => CancelableRequest<string>;
 }

package/dist/source/as-promise/types.js

@@ -8,6 +8,9 @@ export class CancelError extends RequestError {
         this.name = 'CancelError';
         this.code = 'ERR_CANCELED';
     }
+    /**
+    Whether the promise is canceled.
+    */
     get isCanceled() {
         return true;
     }

package/dist/source/core/errors.js

@@ -93,6 +93,7 @@ export class MaxRedirectsError extends RequestError {
 An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
 Includes a `response` property.
 */
+// eslint-disable-next-line @typescript-eslint/naming-convention
 export class HTTPError extends RequestError {
     constructor(response) {
         super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);

package/dist/source/core/index.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
-import { Duplex } from 'stream';
-import { URL } from 'url';
-import { ServerResponse } from 'http';
-import type { ClientRequest } from 'http';
-import type { Socket } from 'net';
+import { Duplex } from 'node:stream';
+import { URL } from 'node:url';
+import { ServerResponse } from 'node:http';
+import type { ClientRequest } from 'node:http';
+import type { Socket } from 'node:net';
 import CacheableRequest from 'cacheable-request';
 import type { Timings } from '@szmarczak/http-timer';
 import type ResponseLike from 'responselike';
@@ -114,7 +114,7 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     flush(): Promise<void>;
     _beforeError(error: Error): void;
     _read(): void;
-    _write(chunk: any, encoding: string | undefined, callback: (error?: Error | null) => void): void;
+    _write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void;
     _final(callback: (error?: Error | null) => void): void;
     _destroy(error: Error | null, callback: (error: Error | null) => void): void;
     pipe<T extends NodeJS.WritableStream>(destination: T, options?: {

package/dist/source/core/index.js

@@ -1,11 +1,14 @@
-import { Duplex } from 'stream';
-import { URL, URLSearchParams } from 'url';
-import http, { ServerResponse } from 'http';
+import process from 'node:process';
+import { Buffer } from 'node:buffer';
+import { Duplex } from 'node:stream';
+import { URL, URLSearchParams } from 'node:url';
+import http, { ServerResponse } from 'node:http';
 import timer from '@szmarczak/http-timer';
 import CacheableRequest from 'cacheable-request';
 import decompressResponse from 'decompress-response';
 import is from '@sindresorhus/is';
 import { buffer as getBuffer } from 'get-stream';
+import { FormDataEncoder, isFormDataLike } from 'form-data-encoder';
 import getBodySize from './utils/get-body-size.js';
 import isFormData from './utils/is-form-data.js';
 import proxyEvents from './utils/proxy-events.js';
@@ -221,6 +224,11 @@ export default class Request extends Duplex {
                 Object.assign(this.options.headers, source.headers);
             }
         });
+        this.on('newListener', event => {
+            if (event === 'retry' && this.listenerCount('retry') > 0) {
+                throw new Error('A retry listener has been attached already.');
+            }
+        });
         try {
             this.options = new Options(url, options, defaults);
             if (!this.options.url) {
@@ -377,7 +385,14 @@ export default class Request extends Duplex {
                         return;
                     }
                     this.destroy();
-                    this.emit('retry', this.retryCount + 1, error);
+                    this.emit('retry', this.retryCount + 1, error, (updatedOptions) => {
+                        const request = new Request(options.url, updatedOptions, options);
+                        request.retryCount = this.retryCount + 1;
+                        process.nextTick(() => {
+                            void request.flush();
+                        });
+                        return request;
+                    });
                     return;
                 }
             }
@@ -395,7 +410,7 @@ export default class Request extends Duplex {
             }
             let data;
             while ((data = response.read()) !== null) {
-                this._downloadedSize += data.length;
+                this._downloadedSize += data.length; // eslint-disable-line @typescript-eslint/restrict-plus-operands
                 const progress = this.downloadProgress;
                 if (progress.percent < 1) {
                     this.emit('downloadProgress', progress);
@@ -404,7 +419,6 @@ export default class Request extends Duplex {
             }
         }
     }
-    // Node.js 12 has incorrect types, so the encoding must be a string
     _write(chunk, encoding, callback) {
         const write = () => {
             this._writeRequest(chunk, encoding, callback);
@@ -493,6 +507,7 @@ export default class Request extends Duplex {
         const { options } = this;
         const { headers } = options;
         const isForm = !is.undefined(options.form);
+        // eslint-disable-next-line @typescript-eslint/naming-convention
         const isJSON = !is.undefined(options.json);
         const isBody = !is.undefined(options.body);
         const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
@@ -504,6 +519,15 @@ export default class Request extends Duplex {
             // Serialize body
             const noContentType = !is.string(headers['content-type']);
             if (isBody) {
+                // Body is spec-compliant FormData
+                if (isFormDataLike(options.body)) {
+                    const encoder = new FormDataEncoder(options.body);
+                    if (noContentType) {
+                        headers['content-type'] = encoder.headers['Content-Type'];
+                    }
+                    headers['content-length'] = encoder.headers['Content-Length'];
+                    options.body = encoder.encode();
+                }
                 // Special case for https://github.com/form-data/form-data
                 if (isFormData(options.body) && noContentType) {
                     headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
@@ -826,7 +850,7 @@ export default class Request extends Duplex {
                 if (is.promise(result)) {
                     // We only need to implement the error handler in order to support HTTP2 caching.
                     // The result will be a promise anyway.
-                    // @ts-expect-error
+                    // @ts-expect-error ignore
                     // eslint-disable-next-line @typescript-eslint/promise-function-async
                     result.once = (event, handler) => {
                         if (event === 'error') {
@@ -1093,7 +1117,6 @@ export default class Request extends Duplex {
         return this._isFromCache;
     }
     get reusedSocket() {
-        // @ts-expect-error `@types/node` has incomplete types
         return this._request?.reusedSocket;
     }
 }

package/dist/source/core/options.d.ts

@@ -1,14 +1,17 @@
 /// <reference types="node" />
-import { URL, URLSearchParams } from 'url';
-import { checkServerIdentity } from 'tls';
-import { request as httpsRequest } from 'https';
-import type { Readable } from 'stream';
-import type { Socket } from 'net';
-import type { SecureContextOptions, DetailedPeerCertificate } from 'tls';
-import type { Agent as HttpAgent, ClientRequest } from 'http';
-import type { RequestOptions as HttpsRequestOptions, Agent as HttpsAgent } from 'https';
+import { Buffer } from 'node:buffer';
+import { URL, URLSearchParams } from 'node:url';
+import { checkServerIdentity } from 'node:tls';
+import http from 'node:http';
+import https from 'node:https';
+import type { Readable } from 'node:stream';
+import type { Socket } from 'node:net';
+import type { SecureContextOptions, DetailedPeerCertificate } from 'node:tls';
+import type { Agent as HttpAgent, ClientRequest } from 'node:http';
+import type { RequestOptions as HttpsRequestOptions, Agent as HttpsAgent } from 'node:https';
 import CacheableLookup from 'cacheable-lookup';
 import http2wrapper, { ClientHttp2Session } from 'http2-wrapper';
+import type { FormDataLike } from 'form-data-encoder';
 import type CacheableRequest from 'cacheable-request';
 import type ResponseLike from 'responselike';
 import type { IncomingMessageWithTimings } from '@szmarczak/http-timer';
@@ -50,39 +53,146 @@ All available hooks of Got.
 */
 export interface Hooks {
     /**
-    Called with plain request options, right before their normalization.
+    Called with the plain request options, right before their normalization.
+
+    The second argument represents the current `Options` instance.
+
+    @default []
+
+    **Note:**
+    > - This hook must be synchronous.
+
+    **Note:**
+    > - This is called every time options are merged.
+
+    **Note:**
+    > - The `options` object may not have the `url` property. To modify it, use a `beforeRequest` hook instead.
+
+    **Note:**
+    > - This hook is called when a new instance of `Options` is created.
+    > - Do not confuse this with the creation of `Request` or `got(…)`.
+
+    **Note:**
+    > - When using `got(url)` or `got(url, undefined, defaults)` this hook will **not** be called.
+
     This is especially useful in conjunction with `got.extend()` when the input needs custom handling.
 
-    __Note #1__: This hook must be synchronous!
+    For example, this can be used to fix typos to migrate from older versions faster.
 
-    __Note #2__: Errors in this hook will be converted into an instances of `RequestError`.
+    @example
+    ```
+    import got from 'got';
 
-    __Note #3__: The options object may not have a `url` property.
-    To modify it, use a `beforeRequest` hook instead.
+    const instance = got.extend({
+        hooks: {
+            init: [
+                plain => {
+                    if ('followRedirects' in plain) {
+                        plain.followRedirect = plain.followRedirects;
+                        delete plain.followRedirects;
+                    }
+                }
+            ]
+        }
+    });
 
-    @default []
+    // Normally, the following would throw:
+    const response = await instance(
+        'https://example.com',
+        {
+            followRedirects: true
+        }
+    );
+
+    // There is no option named `followRedirects`, but we correct it in an `init` hook.
+    ```
+
+    Or you can create your own option and store it in a context:
+
+    ```
+    import got from 'got';
+
+    const instance = got.extend({
+        hooks: {
+            init: [
+                (plain, options) => {
+                    if ('secret' in plain) {
+                        options.context.secret = plain.secret;
+                        delete plain.secret;
+                    }
+                }
+            ],
+            beforeRequest: [
+                options => {
+                    options.headers.secret = options.context.secret;
+                }
+            ]
+        }
+    });
+
+    const {headers} = await instance(
+        'https://httpbin.org/anything',
+        {
+            secret: 'passphrase'
+        }
+    ).json();
+
+    console.log(headers.Secret);
+    //=> 'passphrase'
+    ```
     */
     init: InitHook[];
     /**
-    Called with normalized request options.
-    Got will make no further changes to the request before it is sent.
-    This is especially useful in conjunction with `got.extend()` when you want to create an API client that, for example, uses HMAC-signing.
+    Called right before making the request with `options.createNativeRequestOptions()`.
+
+    This hook is especially useful in conjunction with `got.extend()` when you want to sign your request.
 
     @default []
+
+    **Note:**
+    > - Got will make no further changes to the request before it is sent.
+
+    **Note:**
+    > - Changing `options.json` or `options.form` has no effect on the request. You should change `options.body` instead. If needed, update the `options.headers` accordingly.
+
+    @example
+    ```
+    import got from 'got';
+
+    const response = await got.post(
+        'https://httpbin.org/anything',
+        {
+            json: {payload: 'old'},
+            hooks: {
+                beforeRequest: [
+                    options => {
+                        options.body = JSON.stringify({payload: 'new'});
+                        options.headers['content-length'] = options.body.length.toString();
+                    }
+                ]
+            }
+        }
+    );
+    ```
+
+    **Tip:**
+    > - You can indirectly override the `request` function by early returning a [`ClientRequest`-like](https://nodejs.org/api/http.html#http_class_http_clientrequest) instance or a [`IncomingMessage`-like](https://nodejs.org/api/http.html#http_class_http_incomingmessage) instance. This is very useful when creating a custom cache mechanism.
+    > - [Read more about this tip](https://github.com/sindresorhus/got/blob/main/documentation/cache.md#advanced-caching-mechanisms).
     */
     beforeRequest: BeforeRequestHook[];
     /**
-    Called with normalized request options and the redirect response.
-    Got will make no further changes to the request.
-    This is especially useful when you want to avoid dead sites.
+    The equivalent of `beforeRequest` but when redirecting.
 
     @default []
 
+    **Tip:**
+    > - This is especially useful when you want to avoid dead sites.
+
     @example
     ```
     import got from 'got';
 
-    await got('https://example.com', {
+    const response = await got('https://example.com', {
         hooks: {
             beforeRedirect: [
                 (options, response) => {
@@ -97,19 +207,17 @@ export interface Hooks {
     */
     beforeRedirect: BeforeRedirectHook[];
     /**
-    Called with an `Error` instance.
-    The error is passed to the hook right before it's thrown.
-    This is especially useful when you want to have more detailed errors.
+    Called with a `RequestError` instance. The error is passed to the hook right before it's thrown.
 
-    __Note__: Errors thrown while normalizing input options are thrown directly and not part of this hook.
+    This is especially useful when you want to have more detailed errors.
 
     @default []
 
-    @example
     ```
     import got from 'got';
 
-    await got('https://api.github.com/some-endpoint', {
+    await got('https://api.github.com/repos/sindresorhus/got/commits', {
+        responseType: 'json',
         hooks: {
             beforeError: [
                 error => {
@@ -128,26 +236,31 @@ export interface Hooks {
     */
     beforeError: BeforeErrorHook[];
     /**
-    Called with normalized request options, the error and the retry count.
-  Got will make no further changes to the request.
-    This is especially useful when some extra work is required before the next try.
-
-    __Note__: When using streams, this hook is ignored.
-    __Note__: When retrying in a `afterResponse` hook, all remaining `beforeRetry` hooks will be called without the `error` and `retryCount` arguments.
+    The equivalent of `beforeError` but when retrying. Additionally, there is a second argument `retryCount`, the current retry number.
 
     @default []
 
+    **Note:**
+    > - When using the Stream API, this hook is ignored.
+
+    **Note:**
+    > - When retrying, the `beforeRequest` hook is called afterwards.
+
+    **Note:**
+    > - If no retry occurs, the `beforeError` hook is called instead.
+
+    This hook is especially useful when you want to retrieve the cause of a retry.
+
     @example
     ```
     import got from 'got';
 
-    got.post('https://example.com', {
+    await got('https://httpbin.org/status/500', {
         hooks: {
             beforeRetry: [
-                (options, error, retryCount) => {
-                    if (error.response.statusCode === 413) { // Payload too large
-                        options.body = getNewBody();
-                    }
+                (error, retryCount) => {
+                    console.log(`Retrying [${retryCount}]: ${error.code}`);
+                    // Retrying [1]: ERR_NON_2XX_3XX_RESPONSE
                 }
             ]
         }
@@ -156,14 +269,15 @@ export interface Hooks {
     */
     beforeRetry: BeforeRetryHook[];
     /**
-    Called with [response object](#response) and a retry function.
+    Each function should return the response. This is especially useful when you want to refresh an access token.
 
-    Each function should return the response.
-    This is especially useful when you want to refresh an access token.
+    @default []
 
-    __Note__: When using streams, this hook is ignored.
+    **Note:**
+    > - When using the Stream API, this hook is ignored.
 
-    __Note__: Calling the `retryWithMergedOptions` function will trigger `beforeRetry` hooks. If the retry is successful, all remaining `afterResponse` hooks will be called. In case of an error, `beforeRetry` hooks will be called instead.
+    **Note:**
+    > - Calling the `retryWithMergedOptions` function will trigger `beforeRetry` hooks. If the retry is successful, all remaining `afterResponse` hooks will be called. In case of an error, `beforeRetry` hooks will be called instead.
     Meanwhile the `init`, `beforeRequest` , `beforeRedirect` as well as already executed `afterResponse` hooks will be skipped.
 
     @example
@@ -174,15 +288,17 @@ export interface Hooks {
         hooks: {
             afterResponse: [
                 (response, retryWithMergedOptions) => {
-                    if (response.statusCode === 401) { // Unauthorized
+                    // Unauthorized
+                    if (response.statusCode === 401) {
+                        // Refresh the access token
                         const updatedOptions = {
                             headers: {
-                                token: getNewToken() // Refresh the access token
+                                token: getNewToken()
                             }
                         };
 
-                        // Save for further requests
-                        instance.defaults.options = got.mergeOptions(instance.defaults.options, updatedOptions);
+                        // Update the defaults
+                        instance.defaults.options.merge(updatedOptions);
 
                         // Make a new retry
                         return retryWithMergedOptions(updatedOptions);
@@ -193,7 +309,7 @@ export interface Hooks {
                 }
             ],
             beforeRetry: [
-                (options, error, retryCount) => {
+                error => {
                     // This will be called on `retryWithMergedOptions(...)`
                 }
             ]
@@ -561,12 +677,12 @@ export default class Options {
 
     __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` / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
+    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`.
     */
-    get body(): string | Buffer | Readable | Generator | AsyncGenerator | undefined;
-    set body(value: string | Buffer | Readable | Generator | AsyncGenerator | undefined);
+    get body(): string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined;
+    set body(value: string | Buffer | Readable | Generator | AsyncGenerator | FormDataLike | undefined);
     /**
     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).
 
@@ -984,25 +1100,27 @@ export default class Options {
         headers: Headers;
         timeout: Delays;
         request: RequestFunction | undefined;
+        username: string;
+        password: string;
         json: Record<string, any> | undefined;
         retry: Partial<RetryOptions>;
         agent: Agents;
         h2session: http2wrapper.ClientHttp2Session | undefined;
         decompress: boolean;
         prefixUrl: string | URL;
-        body: string | Readable | Buffer | Generator<unknown, any, unknown> | AsyncGenerator<unknown, any, unknown> | undefined;
+        body: string | Readable | Buffer | Generator<unknown, any, unknown> | AsyncGenerator<unknown, any, unknown> | FormDataLike | undefined;
         form: Record<string, any> | undefined;
         url: string | URL | undefined;
         cookieJar: PromiseCookieJar | ToughCookieJar | undefined;
         ignoreInvalidCookies: boolean;
         searchParams: string | SearchParameters | URLSearchParams | undefined;
         dnsLookup: {
-            (hostname: string, family: import("cacheable-lookup").IPFamily, callback: (error: NodeJS.ErrnoException, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
-            (hostname: string, callback: (error: NodeJS.ErrnoException, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            (hostname: string, family: import("cacheable-lookup").IPFamily, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            (hostname: string, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
             (hostname: string, options: import("cacheable-lookup").LookupOptions & {
                 all: true;
-            }, callback: (error: NodeJS.ErrnoException, result: readonly import("cacheable-lookup").EntryObject[]) => void): void;
-            (hostname: string, options: import("cacheable-lookup").LookupOptions, callback: (error: NodeJS.ErrnoException, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            }, callback: (error: NodeJS.ErrnoException | null, result: readonly import("cacheable-lookup").EntryObject[]) => void): void;
+            (hostname: string, options: import("cacheable-lookup").LookupOptions, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
         } | undefined;
         dnsCache: boolean | CacheableLookup | undefined;
         context: Record<string, unknown>;
@@ -1011,8 +1129,6 @@ export default class Options {
         maxRedirects: number;
         cache: string | boolean | CacheableRequest.StorageAdapter | undefined;
         throwHttpErrors: boolean;
-        username: string;
-        password: string;
         http2: boolean;
         allowGetBody: boolean;
         methodRewriting: boolean;
@@ -1051,15 +1167,15 @@ export default class Options {
         ecdhCurve: string | undefined;
         crl: string | Buffer | (string | Buffer)[] | undefined;
         lookup: {
-            (hostname: string, family: import("cacheable-lookup").IPFamily, callback: (error: NodeJS.ErrnoException, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
-            (hostname: string, callback: (error: NodeJS.ErrnoException, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            (hostname: string, family: import("cacheable-lookup").IPFamily, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            (hostname: string, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
             (hostname: string, options: import("cacheable-lookup").LookupOptions & {
                 all: true;
-            }, callback: (error: NodeJS.ErrnoException, result: readonly import("cacheable-lookup").EntryObject[]) => void): void;
-            (hostname: string, options: import("cacheable-lookup").LookupOptions, callback: (error: NodeJS.ErrnoException, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
+            }, callback: (error: NodeJS.ErrnoException | null, result: readonly import("cacheable-lookup").EntryObject[]) => void): void;
+            (hostname: string, options: import("cacheable-lookup").LookupOptions, callback: (error: NodeJS.ErrnoException | null, address: string, family: import("cacheable-lookup").IPFamily) => void): void;
         } | undefined;
         family: DnsLookupIpVersion;
-        agent: false | Agents | HttpAgent | undefined;
+        agent: false | Agents | http.Agent | undefined;
         setHost: boolean;
         method: Method;
         maxHeaderSize: number | undefined;
@@ -1068,6 +1184,7 @@ export default class Options {
         createConnection: CreateConnectionFunction | undefined;
         timeout: number | undefined;
         h2session: http2wrapper.ClientHttp2Session | undefined;
+        signal?: AbortSignal | undefined;
         protocol?: string | null | undefined;
         host?: string | null | undefined;
         hostname?: string | null | undefined;
@@ -1076,7 +1193,7 @@ export default class Options {
         socketPath?: string | undefined;
         path?: string | null | undefined;
         auth?: string | null | undefined;
-        _defaultAgent?: HttpAgent | undefined;
+        _defaultAgent?: http.Agent | undefined;
         clientCertEngine?: string | undefined;
         privateKeyEngine?: string | undefined;
         privateKeyIdentifier?: string | undefined;
@@ -1090,8 +1207,8 @@ export default class Options {
         immutableMinTimeToLive?: number | undefined;
         ignoreCargoCult?: boolean | undefined;
     };
-    getRequestFunction(): RequestFunction | typeof httpsRequest | undefined;
-    getFallbackRequestFunction(): RequestFunction | typeof httpsRequest | undefined;
+    getRequestFunction(): RequestFunction | typeof https.request | undefined;
+    getFallbackRequestFunction(): RequestFunction | typeof https.request | undefined;
     freeze(): void;
 }
 export {};