@yanglaofish/fishtools 0.5.1 → 0.5.3

package/node_modules/undici/docs/docs/api/ProxyAgent.md

@@ -1,248 +1,131 @@
-# ProxyAgent
+# Class: ProxyAgent
 
-<!--introduced_in=v4.8.2-->
-<!--type=module-->
-<!-- source_link=lib/dispatcher/proxy-agent.js -->
+Extends: `undici.Dispatcher`
 
-> Stability: 2 - Stable
+A Proxy Agent class that implements the Agent API. It allows the connection through proxy in a simple way.
 
-A `ProxyAgent` routes every request through an HTTP, HTTPS, or SOCKS5 proxy
-server. It implements the [`Agent`][] API, so it can be used wherever a
-dispatcher is accepted, for example with [`request`][] or [`fetch`][], or
-installed globally with [`setGlobalDispatcher`][].
+## `new ProxyAgent([options])`
 
-For secure (`https:`) endpoints the proxy connection is established through an
-HTTP `CONNECT` tunnel. SOCKS5 proxies (`socks5:` or `socks:` URIs) are handled
-by delegating to a [`Socks5ProxyAgent`][].
+Arguments:
 
-```mjs
-import { ProxyAgent, setGlobalDispatcher } from 'undici'
-
-const proxyAgent = new ProxyAgent('http://localhost:8000')
-setGlobalDispatcher(proxyAgent)
-```
+* **options** `ProxyAgentOptions` (required) - It extends the `Agent` options.
 
-## Class: `ProxyAgent`
-
-<!-- YAML
-added: v4.8.2
--->
-
-* Extends: {Dispatcher}
-
-`ProxyAgent` keeps an internal [`Agent`][] that creates per-origin dispatchers
-on demand. The proxy connection is set up lazily when the first request to an
-origin is dispatched, then reused for subsequent requests to the same origin.
-
-### `new ProxyAgent(options)`
-
-<!-- YAML
-added: v4.8.2
--->
-
-* `options` {ProxyAgentOptions|string|URL} The proxy URI, or an options object.
-  Required. When a `string` or {URL} is passed it is used as the proxy `uri`.
-  The options object extends {AgentOptions} (omitting `connect`).
-  * `uri` {string} The URI of the proxy server. Required when `options` is an
-    object. Parsed into a {URL} according to the
-    [WHATWG URL Specification][].
-  * `token` {string} A pre-formatted `proxy-authorization` header value sent to
-    the proxy on every request, for example `` `Bearer ${apiKey}` ``.
-  * `auth` {string} A base64-encoded `username:password` credential sent as a
-    `Basic` `proxy-authorization` header. Cannot be combined with `token`.
-  * `headers` {Object} Additional headers sent to the proxy server on the
-    `CONNECT` request (or on every request for an untunneled HTTP proxy).
-    **Default:** `{}`.
-  * `requestTls` {BuildOptions} TLS options for the connection to the request
-    endpoint, passed to the connector builder.
-  * `proxyTls` {BuildOptions} TLS options for the connection to the proxy
-    server, passed to the connector builder.
-  * `clientFactory` {Function} Builds the {Dispatcher} used to talk to the proxy
-    server itself. **Default:** `(origin, opts) => new Pool(origin, opts)`.
-    * `origin` {URL} The proxy origin.
-    * `opts` {Object} The resolved options for the dispatcher.
-    * Returns: {Dispatcher}
-  * `proxyTunnel` {boolean} Forces tunneling through the proxy. By default,
-    Undici detects tunneling based on the request protocol. If the target
-    endpoint uses HTTPS, Undici establishes a `CONNECT` tunnel through the proxy
-    (after the TLS handshake to the proxy itself when the proxy URL is HTTPS).
-    If the target endpoint uses plain HTTP, Undici forwards the request to the
-    proxy using an HTTP/1.1 absolute-form request target (over TLS when the
-    proxy URL is HTTPS), as required by
-    [RFC 9112 §3.2.2](https://www.rfc-editor.org/rfc/rfc9112.html#name-absolute-form).
-    This non-tunneled forwarding path does not negotiate HTTP/2 with the proxy.
-    Set `proxyTunnel` to `true` to force tunneling for plain HTTP requests as
-    well. Currently, there is no way to facilitate HTTP/1.1 IP tunneling as
-    described in
-    [RFC 9484](https://www.rfc-editor.org/rfc/rfc9484.html#name-http-11-request).
-
-Throws an {InvalidArgumentError} when no proxy URI is provided, when
-`clientFactory` is not a function, or when both `auth` and `token` are supplied.
-
-The `proxy-authorization` header is derived, in order of precedence, from
-`token`, then `auth`, then the `username` and `password` embedded in the proxy
-`uri`. Credentials in the URI are URL-decoded before being base64-encoded.
-
-> [!NOTE]
-> Unless {AgentOptions} `connections` is set to `0`, the non-standard
-> `proxy-connection: keep-alive` header is added to the tunnel `CONNECT`
-> request. This includes the default case where `connections` is unset.
-
-The `auth` option is deprecated; use `token` instead.
-
-```mjs
-import { ProxyAgent } from 'undici'
-
-// A string or URL is treated as the proxy uri.
-const a = new ProxyAgent('http://localhost:8000')
-const b = new ProxyAgent(new URL('http://localhost:8000'))
+Returns: `ProxyAgent`
 
-// An options object requires a `uri`.
-const c = new ProxyAgent({ uri: 'http://localhost:8000' })
-
-// With proxy TLS settings.
-const d = new ProxyAgent({
-  uri: 'https://secure.proxy.server',
-  proxyTls: {
-    signal: AbortSignal.timeout(1000),
-  },
-})
-```
+### Parameter: `ProxyAgentOptions`
 
-#### Example - proxy request with the global dispatcher
+Extends: [`AgentOptions`](Agent.md#parameter-agentoptions)
 
-```mjs
-import { setGlobalDispatcher, request, ProxyAgent } from 'undici'
+* **uri** `string | URL` (required) - The URI of the proxy server.  This can be provided as a string, as an instance of the URL class, or as an object with a `uri` property of type string.
+If the `uri` is provided as a string or `uri` is an object with an `uri` property of type string, then it will be parsed into a `URL` object according to the [WHATWG URL Specification](https://url.spec.whatwg.org).
+For detailed information on the parsing process and potential validation errors, please refer to the ["Writing" section](https://url.spec.whatwg.org/#writing) of the WHATWG URL Specification.
+* **token** `string` (optional) - It can be passed by a string of token for authentication.
+* **auth** `string` (**deprecated**) - Use token.
+* **clientFactory** `(origin: URL, opts: Object) => Dispatcher` (optional) - Default: `(origin, opts) => new Pool(origin, opts)`
+* **requestTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the request. It extends from [`Client#ConnectOptions`](/docs/docs/api/Client.md#parameter-connectoptions).
+* **proxyTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the proxy server. It extends from [`Client#ConnectOptions`](/docs/docs/api/Client.md#parameter-connectoptions).
+* **proxyTunnel** `boolean` (optional) - For connections involving secure protocols, Undici will always establish a tunnel via the HTTP2  CONNECT extension. If proxyTunnel is set to true, this will occur for unsecured proxy/endpoint connections as well. Currently, there is no way to facilitate HTTP1 IP tunneling as described in https://www.rfc-editor.org/rfc/rfc9484.html#name-http-11-request. If proxyTunnel is set to false (the default), ProxyAgent connections where both the Proxy and Endpoint are unsecured will issue all requests to the Proxy, and prefix the endpoint request path with the endpoint origin address.
 
-const proxyAgent = new ProxyAgent('http://localhost:8000')
-setGlobalDispatcher(proxyAgent)
+Examples:
 
-const { statusCode, body } = await request('http://localhost:3000/foo')
+```js
+import { ProxyAgent } from 'undici'
 
-console.log('response received', statusCode)
-console.log('data', await body.text())
+const proxyAgent = new ProxyAgent('my.proxy.server')
+// or
+const proxyAgent = new ProxyAgent(new URL('my.proxy.server'))
+// or
+const proxyAgent = new ProxyAgent({ uri: 'my.proxy.server' })
 ```
 
-#### Example - proxy request with a local dispatcher
+#### Example - Basic ProxyAgent instantiation
 
-```mjs
-import { ProxyAgent, request } from 'undici'
-
-const proxyAgent = new ProxyAgent('http://localhost:8000')
+This will instantiate the ProxyAgent. It will not do anything until registered as the agent to use with requests.
 
-const { statusCode, body } = await request('http://localhost:3000/foo', {
-  dispatcher: proxyAgent,
-})
+```js
+import { ProxyAgent } from 'undici'
 
-console.log('response received', statusCode)
-console.log('data', await body.text())
+const proxyAgent = new ProxyAgent('my.proxy.server')
 ```
 
-#### Example - proxy request with authentication
+#### Example - Basic Proxy Request with global agent dispatcher
 
-```mjs
+```js
 import { setGlobalDispatcher, request, ProxyAgent } from 'undici'
 
-const proxyAgent = new ProxyAgent({
-  uri: 'http://localhost:8000',
-  token: `Basic ${Buffer.from('username:password').toString('base64')}`,
-})
+const proxyAgent = new ProxyAgent('my.proxy.server')
 setGlobalDispatcher(proxyAgent)
 
-const { statusCode } = await request('http://localhost:3000/foo')
+const { statusCode, body } = await request('http://localhost:3000/foo')
+
+console.log('response received', statusCode) // response received 200
 
-console.log('response received', statusCode)
+for await (const data of body) {
+  console.log('data', data.toString('utf8')) // data foo
+}
 ```
 
-### `proxyAgent.dispatch(options, handler)`
+#### Example - Basic Proxy Request with local agent dispatcher
 
-<!-- YAML
-added: v4.8.2
--->
+```js
+import { ProxyAgent, request } from 'undici'
 
-* `options` {AgentDispatchOptions} Extends {DispatchOptions}.
-  * `origin` {string|URL} The origin to dispatch the request against. Required.
-* `handler` {DispatchHandler}
-* Returns: {boolean} `false` if the dispatcher is busy and the caller should
-  wait for the [`'drain'`][] event before dispatching again.
+const proxyAgent = new ProxyAgent('my.proxy.server')
 
-Dispatches the request through the proxy. Throws an {InvalidArgumentError} if
-the request headers contain a `proxy-authorization` header, which must instead
-be supplied through the constructor's `token` or `auth` option. A `host` header
-is derived from `options.origin` when one is not already present. Implements
-[`Dispatcher.dispatch()`][].
+const {
+  statusCode,
+  body
+} = await request('http://localhost:3000/foo', { dispatcher: proxyAgent })
 
-### `proxyAgent.close()`
+console.log('response received', statusCode) // response received 200
 
-<!-- YAML
-added: v4.8.2
-changes:
-  - version: v7.10.0
-    pr-url: https://github.com/nodejs/undici/pull/4180
-    description: Untunneled HTTP-to-HTTP proxy connections match `curl` behavior.
--->
+for await (const data of body) {
+  console.log('data', data.toString('utf8')) // data foo
+}
+```
 
-* Returns: {Promise<void>}
+#### Example - Basic Proxy Request with authentication
 
-Closes the proxy agent and waits for its internal agent and proxy client (when
-present) to close before resolving. Implements [`Dispatcher.close()`][].
+```js
+import { setGlobalDispatcher, request, ProxyAgent } from 'undici';
 
-```mjs
-import { ProxyAgent, setGlobalDispatcher } from 'undici'
+const proxyAgent = new ProxyAgent({
+  uri: 'my.proxy.server',
+  // token: 'Bearer xxxx'
+  token: `Basic ${Buffer.from('username:password').toString('base64')}`
+});
+setGlobalDispatcher(proxyAgent);
 
-const proxyAgent = new ProxyAgent('http://localhost:8000')
-setGlobalDispatcher(proxyAgent)
+const { statusCode, body } = await request('http://localhost:3000/foo');
 
-await proxyAgent.close()
-```
+console.log('response received', statusCode); // response received 200
 
-### `proxyAgent.request(options[, callback])`
+for await (const data of body) {
+  console.log('data', data.toString('utf8')); // data foo
+}
+```
 
-<!-- YAML
-added: v5.0.0
--->
+### `ProxyAgent.close()`
 
-See [`Dispatcher.request()`][]. The request is routed through the proxy.
+Closes the proxy agent and waits for registered pools and clients to also close before resolving.
 
-#### Example - proxy request with `fetch`
+Returns: `Promise<void>`
 
-```mjs
-import { ProxyAgent, fetch } from 'undici'
+#### Example - clean up after tests are complete
 
-const proxyAgent = new ProxyAgent('http://localhost:8000')
+```js
+import { ProxyAgent, setGlobalDispatcher } from 'undici'
 
-const response = await fetch('http://localhost:3000/foo', {
-  dispatcher: proxyAgent,
-  method: 'GET',
-})
+const proxyAgent = new ProxyAgent('my.proxy.server')
+setGlobalDispatcher(proxyAgent)
 
-console.log('response status', response.status)
-console.log('response data', await response.text())
+await proxyAgent.close()
 ```
 
-#### Example - HTTPS tunneling
-
-```mjs
-import { ProxyAgent, fetch } from 'undici'
+### `ProxyAgent.dispatch(options, handlers)`
 
-const proxyAgent = new ProxyAgent('https://secure.proxy.server')
+Implements [`Agent.dispatch(options, handlers)`](Agent.md#parameter-agentdispatchoptions).
 
-const response = await fetch('https://secure.endpoint.com/api/data', {
-  dispatcher: proxyAgent,
-  method: 'GET',
-})
-
-console.log('response status', response.status)
-console.log('response data', await response.json())
-```
+### `ProxyAgent.request(options[, callback])`
 
-[WHATWG URL Specification]: https://url.spec.whatwg.org
-[`'drain'`]: Dispatcher.md#event-drain
-[`Agent`]: Agent.md#class-agent
-[`Dispatcher.close()`]: Dispatcher.md#dispatcherclosecallback-promise
-[`Dispatcher.dispatch()`]: Dispatcher.md#dispatcherdispatchoptions-handler
-[`Dispatcher.request()`]: Dispatcher.md#dispatcherrequestoptions-callback
-[`Socks5ProxyAgent`]: Socks5ProxyAgent.md#class-socks5proxyagent
-[`fetch`]: Fetch.md
-[`request`]: Dispatcher.md#dispatcherrequestoptions-callback
-[`setGlobalDispatcher`]: Dispatcher.md#setglobaldispatcherdispatcher
+See [`Dispatcher.request(options [, callback])`](Dispatcher.md#dispatcherrequestoptions-callback).

package/node_modules/undici/docs/docs/api/RedirectHandler.md

@@ -1,276 +1,96 @@
-# RedirectHandler
-
-<!--introduced_in=v4.0.0-->
-<!--type=module-->
-<!-- source_link=lib/handler/redirect-handler.js -->
-
-> Stability: 2 - Stable
-
-A dispatch handler that follows HTTP redirects on behalf of another handler. It
-wraps a downstream `handler` and a `dispatch` function: when a redirectable
-response is received it transparently re-dispatches the request to the new
-location, forwarding the lifecycle callbacks to the wrapped `handler` only once a
-final (non-redirect) response is reached.
-
-Redirects are followed for the `300`, `301`, `302`, `303`, `307`, and `308`
-status codes, up to `maxRedirections` hops. Following the relevant HTTP
-specifications, the method is downgraded to `GET` for `301`/`302` `POST`
-responses and for `303` responses with any method other than `HEAD`, request
-bodies that have already been consumed are not replayed, and headers that refer
-to the original URL (such as `host`) are stripped on each hop, with additional
-credential headers removed on cross-origin redirects.
-
-```mjs
-import { RedirectHandler } from 'undici'
-```
-
-```cjs
-const { RedirectHandler } = require('undici')
-```
-
-Most users do not construct `RedirectHandler` directly. The `maxRedirections`
-option on [`Dispatcher`][] methods and the higher-level clients use it
-internally.
-
-## Class: `RedirectHandler`
-
-<!-- YAML
-added: v4.0.0
--->
-
-* Extends: {DispatchHandler}
-
-Implements the [`DispatchHandler`][] interface, delegating every callback to the
-wrapped `handler` while intercepting redirect responses.
-
-### `new RedirectHandler(dispatch, maxRedirections, opts, handler)`
-
-<!-- YAML
-added: v4.0.0
--->
-
-* `dispatch` {Function} The dispatch function used to issue the original request
-  and every subsequent redirect. Called as `dispatch(options, handler)`.
-* `maxRedirections` {number|null} The maximum number of redirects to follow. Must
-  be a non-negative integer or `null`. When `null` or `0`, no redirects are
-  followed and redirect responses are passed through to the wrapped `handler`.
-* `opts` {DispatchOptions} The dispatch options for the request. In addition to
-  the standard dispatch options, the following redirect-specific fields are
-  recognized:
-  * `throwOnMaxRedirect` {boolean} When `true`, an error is thrown once
-    `maxRedirections` is reached instead of returning the last redirect response.
-    **Default:** `false`.
-  * `stripHeadersOnRedirect` {string[]} Header names to remove from the request on
-    every redirect hop. **Default:** `null`.
-  * `stripHeadersOnCrossOriginRedirect` {string[]} Additional header names to
-    remove from the request when a redirect points to a different origin.
-    **Default:** `null`.
-* `handler` {DispatchHandler} The downstream handler that receives the lifecycle
-  callbacks for the final response.
-
-Throws an [`InvalidArgumentError`][] when `maxRedirections` is not a non-negative
-integer, when `throwOnMaxRedirect` is not a boolean, or when either
-`stripHeadersOnRedirect` or `stripHeadersOnCrossOriginRedirect` is not an array of
-header-name strings.
-
-```mjs
-import { Client, RedirectHandler } from 'undici'
-
-const client = new Client('http://example.com')
-const dispatch = client.dispatch.bind(client)
-
-const handler = new RedirectHandler(dispatch, 5, {
-  method: 'GET',
-  path: '/',
-  origin: 'http://example.com',
-}, {
-  onRequestStart () {},
-  onResponseStart (controller, statusCode, headers) {
-    console.log(statusCode)
-  },
-  onResponseData (controller, chunk) {},
-  onResponseEnd () {},
-})
-
-dispatch({ method: 'GET', path: '/', origin: 'http://example.com' }, handler)
-```
-
-### Static method: `RedirectHandler.buildDispatch(dispatcher, maxRedirections)`
-
-<!-- YAML
-added: v7.0.0
--->
-
-* `dispatcher` {Dispatcher} The dispatcher whose `dispatch` method is wrapped.
-* `maxRedirections` {number|null} The maximum number of redirects to follow. Must
-  be a non-negative integer or `null`.
-* Returns: {Function} A `dispatch(options, handler)` function that wraps each call
-  in a `RedirectHandler` before delegating to `dispatcher`.
-
-Builds a redirect-aware dispatch function from an existing dispatcher. The
-returned function has the same shape as `dispatcher.dispatch` but follows
-redirects automatically. Throws an [`InvalidArgumentError`][] when
-`maxRedirections` is not a non-negative integer.
-
-```mjs
-import { Client, RedirectHandler } from 'undici'
-
-const client = new Client('http://example.com')
-const dispatch = RedirectHandler.buildDispatch(client, 5)
+# Class: RedirectHandler
 
-dispatch({ method: 'GET', path: '/', origin: 'http://example.com' }, {
-  onRequestStart () {},
-  onResponseStart (controller, statusCode) {
-    console.log(statusCode)
-  },
-  onResponseData () {},
-  onResponseEnd () {},
-})
-```
+A class that handles redirection logic for HTTP requests.
 
-### `redirectHandler.onRequestStart(controller, context)`
+## `new RedirectHandler(dispatch, maxRedirections, opts, handler, redirectionLimitReached)`
 
-<!-- YAML
-added: v7.0.0
--->
+Arguments:
 
-* `controller` {DispatchController} The controller for the in-flight request.
-* `context` {Object} The dispatch context.
+- **dispatch** `function` - The dispatch function to be called after every retry.
+- **maxRedirections** `number` - Maximum number of redirections allowed.
+- **opts** `object` - Options for handling redirection.
+- **handler** `object` - An object containing handlers for different stages of the request lifecycle.
+- **redirectionLimitReached** `boolean` (default: `false`) - A flag that the implementer can provide to enable or disable the feature. If set to `false`, it indicates that the caller doesn't want to use the feature and prefers the old behavior.
 
-Forwards the request-start event to the wrapped `handler`, augmenting `context`
-with the current redirect `history`.
+Returns: `RedirectHandler`
 
-### `redirectHandler.onRequestUpgrade(controller, statusCode, headers, socket)`
+### Parameters
 
-<!-- YAML
-added: v7.0.0
--->
+- **dispatch** `(options: Dispatch.DispatchOptions, handlers: Dispatch.DispatchHandlers) => Promise<Dispatch.DispatchResponse>` (required) - Dispatch function to be called after every redirection.
+- **maxRedirections** `number` (required) - Maximum number of redirections allowed.
+- **opts** `object` (required) - Options for handling redirection.
+- **handler** `object` (required) - Handlers for different stages of the request lifecycle.
+- **redirectionLimitReached** `boolean` (default: `false`) - A flag that the implementer can provide to enable or disable the feature. If set to `false`, it indicates that the caller doesn't want to use the feature and prefers the old behavior.
 
-* `controller` {DispatchController} The controller for the in-flight request.
-* `statusCode` {number} The HTTP status code of the upgrade response.
-* `headers` {Object} The response headers.
-* `socket` {Duplex} The upgraded socket.
+### Properties
 
-Forwards a connection upgrade to the wrapped `handler`.
+- **location** `string` - The current redirection location.
+- **abort** `function` - The abort function.
+- **opts** `object` - The options for handling redirection.
+- **maxRedirections** `number` - Maximum number of redirections allowed.
+- **handler** `object` - Handlers for different stages of the request lifecycle.
+- **history** `Array` - An array representing the history of URLs during redirection.
+- **redirectionLimitReached** `boolean` - Indicates whether the redirection limit has been reached.
 
-### `redirectHandler.onResponseStart(controller, statusCode, headers, statusMessage)`
+### Methods
 
-<!-- YAML
-added: v7.0.0
--->
+#### `onConnect(abort)`
 
-* `controller` {DispatchController} The controller for the in-flight request.
-* `statusCode` {number} The HTTP status code of the response.
-* `headers` {Object} The response headers.
-* `statusMessage` {string} The HTTP status message.
+Called when the connection is established.
 
-Inspects the response headers to decide whether to follow a redirect. When the
-status code is redirectable, the `maxRedirections` limit has not been reached, and
-the request body has not been consumed, the `location` property is set, the method
-and headers are adjusted for the next hop, and the response is not forwarded.
-Otherwise the event is forwarded to the wrapped `handler`.
+Parameters:
 
-Throws when `throwOnMaxRedirect` is `true` and the number of recorded redirects
-has reached `maxRedirections`, and throws an [`InvalidArgumentError`][] if a
-redirect loop is detected (for example when a [`Client`][] or [`Pool`][] is used
-for a cross-origin redirect; use an [`Agent`][] instead).
+- **abort** `function` - The abort function.
 
-### `redirectHandler.onResponseData(controller, chunk)`
+#### `onUpgrade(statusCode, headers, socket)`
 
-<!-- YAML
-added: v7.0.0
--->
+Called when an upgrade is requested.
 
-* `controller` {DispatchController} The controller for the in-flight request.
-* `chunk` {Buffer} A chunk of the response body.
+Parameters:
 
-Forwards body data to the wrapped `handler`. While a redirect is pending
-(`location` is set), the `3xx` response body is ignored.
+- **statusCode** `number` - The HTTP status code.
+- **headers** `object` - The headers received in the response.
+- **socket** `object` - The socket object.
 
-### `redirectHandler.onResponseEnd(controller, trailers)`
+#### `onError(error)`
 
-<!-- YAML
-added: v7.0.0
--->
+Called when an error occurs.
 
-* `controller` {DispatchController} The controller for the in-flight request.
-* `trailers` {Object} The response trailers.
+Parameters:
 
-Completes the response. When a redirect is pending, the request is re-dispatched
-to the new `location`; otherwise the end event is forwarded to the wrapped
-`handler`.
+- **error** `Error` - The error that occurred.
 
-### `redirectHandler.onResponseError(controller, error)`
+#### `onHeaders(statusCode, headers, resume, statusText)`
 
-<!-- YAML
-added: v7.0.0
--->
+Called when headers are received.
 
-* `controller` {DispatchController} The controller for the in-flight request.
-* `error` {Error} The error that occurred.
+Parameters:
 
-Forwards the error to the wrapped `handler`.
+- **statusCode** `number` - The HTTP status code.
+- **headers** `object` - The headers received in the response.
+- **resume** `function` - The resume function.
+- **statusText** `string` - The status text.
 
-### `redirectHandler.location`
+#### `onData(chunk)`
 
-<!-- YAML
-added: v4.0.0
--->
+Called when data is received.
 
-* Type: {string|null}
+Parameters:
 
-The `Location` header value of the redirect currently being followed, or `null`
-when no redirect is pending and the response is being passed through to the
-wrapped `handler`.
+- **chunk** `Buffer` - The data chunk received.
 
-### `redirectHandler.opts`
+#### `onComplete(trailers)`
 
-<!-- YAML
-added: v7.12.0
--->
+Called when the request is complete.
 
-* Type: {DispatchOptions}
+Parameters:
 
-A copy of the dispatch options for the next request. It excludes the redirect
-control fields (`maxRedirections`, `stripHeadersOnRedirect`, and
-`stripHeadersOnCrossOriginRedirect`) and is mutated on each hop to reflect the
-updated method, path, origin, and headers.
+- **trailers** `object` - The trailers received.
 
-### `redirectHandler.maxRedirections`
+#### `onBodySent(chunk)`
 
-<!-- YAML
-added: v4.0.0
--->
+Called when the request body is sent.
 
-* Type: {number|null}
+Parameters:
 
-The maximum number of redirects this handler will follow.
-
-### `redirectHandler.handler`
-
-<!-- YAML
-added: v4.0.0
--->
-
-* Type: {DispatchHandler}
-
-The wrapped downstream handler that receives the lifecycle callbacks for the final
-response.
-
-### `redirectHandler.history`
-
-<!-- YAML
-added: v4.0.0
--->
-
-* Type: {URL[]}
-
-The ordered list of URLs visited while following redirects. It is used to enforce
-`maxRedirections` and to detect redirect loops.
-
-[`Agent`]: Agent.md#class-agent
-[`Client`]: Client.md#class-client
-[`Dispatcher`]: Dispatcher.md#class-dispatcher
-[`DispatchHandler`]: Dispatcher.md#parameter-dispatchhandler
-[`InvalidArgumentError`]: Errors.md#class-invalidargumenterror
-[`Pool`]: Pool.md#class-pool
+- **chunk** `Buffer` - The chunk of the request body sent.