PendingRequest

Apply the callback if the given "value" is (or resolves to) truthy.

Apply the callback if the given "value" is (or resolves to) falsy.

Register a custom macro.

Macros persist in a static property for the worker lifetime and apply to every subsequent call on the macroable class.

Mix another object into the class.

Delegates to macro() for each method; registered macros persist in a static property for the worker lifetime.

Check if macro is registered.

Flush the existing macros.

Clears worker-wide macros; concurrent coroutines may resolve different methods depending on timing.

Dynamically handle calls to the class.

Dynamically handle calls to the class.

Create a new HTTP Client instance.

Set the base URL for the pending request.

Attach a raw body to the request.

Indicate the request contains JSON.

Indicate the request contains form parameters.

Attach a file to the request.

Indicate the request is a multi-part form request.

Specify the body format of the request.

Set the given query parameters in the request URI.

Specify the request's content type.

Indicate that JSON should be returned by the server.

Indicate the type of content that should be returned by the server.

Add the given headers to the request.

Add the given header to the request.

Replace the given headers on the request.

Specify the basic authentication username and password for the request.

Specify the digest authentication username and password for the request.

Specify an authorization token for the request.

Specify the user agent for the request.

Specify the URL parameters that can be substituted into the request URL.

Specify a cookie and its attributes for the request.

Specify the cookies that should be included with the request.

Specify the maximum number of redirects to allow.

Indicate that redirects should not be followed.

Indicate that TLS certificates should not be verified.

Restrict the request's destinations to those the given policy allows.

The policy checks and pins every physical request, including each redirect, to the addresses it vetted. Faked requests and clients supplied through setClient() never reach it.

Resolve and pin a destination within this request's timeout limits.

Hostname pins use an isolated transport; literal addresses can reuse connections. Disable automatic redirects and send the returned URI so its hostname matches the pins.

Specify the path where the body of the response should be stored.

Specify the timeout (in seconds) for the request.

Specify the connect timeout (in seconds) for the request.

Specify the number of times the request should be attempted.

Replace the specified options on the request.

Add new middleware the client handler stack.

Prepend new middleware to the client handler stack.

Add new request middleware the client handler stack.

Add new response middleware the client handler stack.

Set arbitrary attributes to store with the request.

Get the attributes stored with the request.

Indicate that Telescope should not record this request.

Set Telescope tags for this request.

Indicate that OpenTelemetry should trace this request.

Indicate that OpenTelemetry should not trace this request.

Indicate that trace context should not be automatically added to this request.

The request may still be traced locally.

Add a new "before sending" callback to the request.

Add a new callback to execute after the response is built.

Throw an exception if a server or client error occurs.

Throw an exception if a server or client error occurred and the given condition evaluates to true.

Throw an exception if a server or client error occurred and the given condition evaluates to false.

Dump the request before sending.

Dump the request before sending and end the script.

Issue a GET request to the given URL.

Issue a HEAD request to the given URL.

Issue a QUERY request to the given URL.

Issue a POST request to the given URL.

Issue a PATCH request to the given URL.

Issue a PUT request to the given URL.

Issue a DELETE request to the given URL.

Send the request to the given URL.

Substitute the URL parameters in the given URL.

Parse the given HTTP options and set the appropriate additional options.

Parse multi-part form data.

Wrap the multipart stream resources in PSR-7 streams so they are not closed between retry attempts.

Rewind the seekable multipart streams so each attempt contains the full part contents.

Send an asynchronous request to the given URL.

Handle the response of an asynchronous request.

Get the maximum number of attempts for the request.

Get the delay in milliseconds before the next retry attempt.

Send a request either synchronously or asynchronously.

Get the request data as an array so that we can attach it to the request for convenient assertions.

Normalize the given request options.

Normalize the given header values.

Normalize the given header value.

Normalize non-finite floats within a nested array.

Normalize the given multipart option.

Normalize the given multipart headers.

Normalize the given request option value.

Normalize a query supplied to a GET request.

Normalize nested structured data values.

Normalize a scalar to a string without triggering PHP 8.5 non-finite float warnings.

Ensure the given request body can be passed to Guzzle.

Populate the given response with additional data.

Build the Guzzle client.

Create a new Guzzle client.

Build the Guzzle client handler stack.

Create a request-owned transport for destination pinning.

Add the necessary handlers to the given handler stack.

Build the prepared body tracking handler.

Build the before sending handler.

Build the recorder handler.

Build the stub handler.

Get the sink stub handler callback.

A sink that stops accepting the body fails the request as a transport would, with the response, so the callback also takes the request. A subclass decorating the callback may still pass the response alone, as Laravel's callback takes it; the request being sent is used then.

Return idle database sessions before waiting for an external service.

Build the destination policy handler.

Send one physical request to the addresses the destination policy vetted.

Execute the "before sending" callbacks.

Replace the given options with the current request options.

Create a new response instance using the given PSR response.

Execute the "after response" callbacks.

Register a stub callable that will intercept requests and be able to return stub responses.

Indicate that an exception should be thrown if any request is not faked.

Allow stray, unfaked requests for specific URL patterns.

Determine if the given URL is allowed as a stray request.

Toggle asynchronicity in requests.

Retrieve the pending request promise.

Dispatch the RequestSending event if a dispatcher is available.

Dispatch the ResponseReceived event if a dispatcher is available.

Dispatch the ConnectionFailed event if a dispatcher is available.

Indicate that request exceptions should be truncated to the given length.

Indicate that request exceptions should not be truncated.

Get the PSR-7 response carried by the given exception, if any.

Handle the given transport exception.

Handle the given transport exception that carried a response.

Preserve an asynchronous transfer failure even when its response status is successful.

Set the client instance.

The client owns its whole handler stack, so destination policies do not apply to it.

Create a new client instance using the given handler.

Destination-restricted requests reject custom handlers, since their pins only bind the cURL handler.

Get the pending request options.

Set the pending request connection.

Get the pending request connection.

Get the pending request connection configuration.

Get the effective request-option preset for the selected connection.

Merge HTTP option layers using the request-option merge rules.

Merge an option value from a later layer over the current value.

Maps merge by key, with later values winning. Lists such as header values, auth credentials and redirect protocols are replaced whole, since merging them by index would mix entries from both layers. The lists of a mergeable option, such as multipart parts, accumulate instead.

Reject options whose ownership belongs to dedicated APIs.

Flush all static state.