effect 4.0.6 → 4.1.0

package/dist/http/HttpClient.d.ts

@@ -16,9 +16,11 @@ import type { NonEmptyReadonlyArray } from "../Array.ts";
 import * as Context from "../Context.ts";
 import * as Duration from "../Duration.ts";
 import * as Effect from "../Effect.ts";
+import * as Exit from "../Exit.ts";
 import * as Fiber from "../Fiber.ts";
 import * as Inspectable from "../Inspectable.ts";
 import * as Layer from "../Layer.ts";
+import type * as CircuitBreaker from "../persistence/CircuitBreaker.ts";
 import type * as RateLimiter from "../persistence/RateLimiter.ts";
 import { type Pipeable } from "../Pipeable.ts";
 import * as Predicate from "../Predicate.ts";
@@ -931,6 +933,427 @@ export declare const withRateLimiter: {
      */
     <E, R>(self: HttpClient.With<E, R>, options: WithRateLimiter.Options): HttpClient.With<E | RateLimiter.RateLimiterError, R>;
 };
+/**
+ * Namespace containing configuration types for `withCircuitBreaker`.
+ *
+ * @stability experimental
+ * @since 4.0.6
+ */
+export declare namespace WithCircuitBreaker {
+    /**
+     * Options used to configure `withCircuitBreaker`.
+     *
+     * @stability experimental
+     * @category circuit breaking
+     * @since 4.0.6
+     */
+    interface Options<E, R2 = never> {
+        /**
+         * The `CircuitBreaker` service that guards each request.
+         */
+        readonly breaker: CircuitBreaker.CircuitBreaker;
+        /**
+         * The circuit key for a request. Requests with the same key share one
+         * circuit. Defaults to the request origin, falling back to the raw request
+         * URL when it cannot be parsed.
+         */
+        readonly key?: string | ((request: HttpClientRequest.HttpClientRequest) => string) | undefined;
+        /**
+         * Classifies the `Exit` of each request that the breaker admitted.
+         * Defaults to `circuitBreakerClassifier`.
+         */
+        readonly classify?: ((exit: Exit.Exit<HttpClientResponse.HttpClientResponse, E>) => CircuitBreaker.Outcome | Effect.Effect<CircuitBreaker.Outcome, never, R2>) | undefined;
+    }
+}
+/**
+ * Guards requests with a `CircuitBreaker`.
+ *
+ * **Details**
+ *
+ * Requests are keyed by origin unless `key` is set, and classified with
+ * `circuitBreakerClassifier` unless `classify` is set. A rejected request
+ * fails with `CircuitBreakerError` without reaching the wrapped client.
+ *
+ * Apply it after `withRateLimiter` and `retryTransient`, so the breaker sees
+ * one outcome per call and an open circuit skips the retry loop.
+ * `retryTransient` never retries a `CircuitBreakerError`. A custom `classify`
+ * can delegate the cases it doesn't handle to `circuitBreakerClassifier`.
+ *
+ * **Gotchas**
+ *
+ * - The breaker only sees the response headers. To count an error in the
+ *   body, lift it into the error channel below the breaker with
+ *   `transformResponse` and count it in `classify`.
+ * - `withRateLimiter` retries `429` without limit by default, which can hold
+ *   the probe slot for minutes. Set its `times`.
+ * - A rejected request has no client span. The rejection fails the caller's
+ *   span instead.
+ *
+ * **Example** (Guarding an API in the recommended order)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Layer, Ref, Schedule } from "effect"
+ * import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
+ * import { CircuitBreaker, RateLimiter } from "effect/persistence"
+ *
+ * const program = Effect.gen(function*() {
+ *   const requests = yield* Ref.make(0)
+ *   // A dependency that always answers 503.
+ *   const unavailable = HttpClient.make((request) =>
+ *     Effect.as(Ref.update(requests, (n) => n + 1), HttpClientResponse.fromWeb(request, new Response(null, { status: 503 })))
+ *   )
+ *
+ *   const breaker = yield* CircuitBreaker.make({
+ *     tripPolicy: CircuitBreaker.consecutive(1),
+ *     openDuration: "30 seconds"
+ *   })
+ *   const client = unavailable.pipe(
+ *     HttpClient.withRateLimiter({
+ *       limiter: yield* RateLimiter.RateLimiter,
+ *       key: "inventory",
+ *       limit: 100,
+ *       window: "1 second",
+ *       times: 3
+ *     }),
+ *     HttpClient.retryTransient({ times: 2, schedule: Schedule.exponential("1 millis") }),
+ *     HttpClient.withCircuitBreaker({ breaker })
+ *   )
+ *
+ *   // Three attempts, then the breaker records one failure and opens.
+ *   yield* client.execute(HttpClientRequest.get("http://inventory.test/items"))
+ *   // Rejected before the retry loop starts, so no further request is sent.
+ *   const rejected = yield* Effect.flip(client.execute(HttpClientRequest.get("http://inventory.test/items")))
+ *
+ *   return [yield* Ref.get(requests), rejected._tag]
+ * }).pipe(
+ *   Effect.scoped,
+ *   Effect.provide(Layer.merge(
+ *     CircuitBreaker.layerStoreMemory(),
+ *     RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory))
+ *   ))
+ * )
+ *
+ * await Effect.runPromise(program) // => [3, "CircuitBreakerError"]
+ * ```
+ *
+ * **Example** (Counting an error in the body as a failure)
+ *
+ * This API answers `200` with `{ "status": "degraded" }` when it is failing.
+ *
+ * ```ts import.meta.vitest
+ * import { Data, Effect, Exit, Option } from "effect"
+ * import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
+ * import { CircuitBreaker } from "effect/persistence"
+ *
+ * class Degraded extends Data.TaggedError("Degraded") {}
+ *
+ * const degraded = HttpClient.make((request) =>
+ *   Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ status: "degraded" })))
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ *   const breaker = yield* CircuitBreaker.make({
+ *     tripPolicy: CircuitBreaker.consecutive(1),
+ *     openDuration: "30 seconds"
+ *   })
+ *   const client = degraded.pipe(
+ *     HttpClient.transformResponse(Effect.flatMap((response) =>
+ *       Effect.flatMap(response.json, (body) =>
+ *         typeof body === "object" && body !== null && "status" in body && body.status === "degraded"
+ *           ? Effect.fail(new Degraded())
+ *           : Effect.succeed(response))
+ *     )),
+ *     HttpClient.withCircuitBreaker({
+ *       breaker,
+ *       classify: (exit) =>
+ *         Option.exists(Exit.findErrorOption(exit), (error) => error._tag === "Degraded")
+ *           ? CircuitBreaker.failure()
+ *           : HttpClient.circuitBreakerClassifier(exit)
+ *     })
+ *   )
+ *
+ *   yield* Effect.flip(client.get("http://status.test/"))
+ *   const state = yield* breaker.state("http://status.test")
+ *   return state._tag
+ * }).pipe(Effect.scoped, Effect.provide(CircuitBreaker.layerStoreMemory()))
+ *
+ * await Effect.runPromise(program) // => "Open"
+ * ```
+ *
+ * @stability experimental
+ * @category circuit breaking
+ * @since 4.0.6
+ */
+export declare const withCircuitBreaker: {
+    /**
+     * Guards requests with a `CircuitBreaker`.
+     *
+     * **Details**
+     *
+     * Requests are keyed by origin unless `key` is set, and classified with
+     * `circuitBreakerClassifier` unless `classify` is set. A rejected request
+     * fails with `CircuitBreakerError` without reaching the wrapped client.
+     *
+     * Apply it after `withRateLimiter` and `retryTransient`, so the breaker sees
+     * one outcome per call and an open circuit skips the retry loop.
+     * `retryTransient` never retries a `CircuitBreakerError`. A custom `classify`
+     * can delegate the cases it doesn't handle to `circuitBreakerClassifier`.
+     *
+     * **Gotchas**
+     *
+     * - The breaker only sees the response headers. To count an error in the
+     *   body, lift it into the error channel below the breaker with
+     *   `transformResponse` and count it in `classify`.
+     * - `withRateLimiter` retries `429` without limit by default, which can hold
+     *   the probe slot for minutes. Set its `times`.
+     * - A rejected request has no client span. The rejection fails the caller's
+     *   span instead.
+     *
+     * **Example** (Guarding an API in the recommended order)
+     *
+     * ```ts import.meta.vitest
+     * import { Effect, Layer, Ref, Schedule } from "effect"
+     * import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
+     * import { CircuitBreaker, RateLimiter } from "effect/persistence"
+     *
+     * const program = Effect.gen(function*() {
+     *   const requests = yield* Ref.make(0)
+     *   // A dependency that always answers 503.
+     *   const unavailable = HttpClient.make((request) =>
+     *     Effect.as(Ref.update(requests, (n) => n + 1), HttpClientResponse.fromWeb(request, new Response(null, { status: 503 })))
+     *   )
+     *
+     *   const breaker = yield* CircuitBreaker.make({
+     *     tripPolicy: CircuitBreaker.consecutive(1),
+     *     openDuration: "30 seconds"
+     *   })
+     *   const client = unavailable.pipe(
+     *     HttpClient.withRateLimiter({
+     *       limiter: yield* RateLimiter.RateLimiter,
+     *       key: "inventory",
+     *       limit: 100,
+     *       window: "1 second",
+     *       times: 3
+     *     }),
+     *     HttpClient.retryTransient({ times: 2, schedule: Schedule.exponential("1 millis") }),
+     *     HttpClient.withCircuitBreaker({ breaker })
+     *   )
+     *
+     *   // Three attempts, then the breaker records one failure and opens.
+     *   yield* client.execute(HttpClientRequest.get("http://inventory.test/items"))
+     *   // Rejected before the retry loop starts, so no further request is sent.
+     *   const rejected = yield* Effect.flip(client.execute(HttpClientRequest.get("http://inventory.test/items")))
+     *
+     *   return [yield* Ref.get(requests), rejected._tag]
+     * }).pipe(
+     *   Effect.scoped,
+     *   Effect.provide(Layer.merge(
+     *     CircuitBreaker.layerStoreMemory(),
+     *     RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory))
+     *   ))
+     * )
+     *
+     * await Effect.runPromise(program) // => [3, "CircuitBreakerError"]
+     * ```
+     *
+     * **Example** (Counting an error in the body as a failure)
+     *
+     * This API answers `200` with `{ "status": "degraded" }` when it is failing.
+     *
+     * ```ts import.meta.vitest
+     * import { Data, Effect, Exit, Option } from "effect"
+     * import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
+     * import { CircuitBreaker } from "effect/persistence"
+     *
+     * class Degraded extends Data.TaggedError("Degraded") {}
+     *
+     * const degraded = HttpClient.make((request) =>
+     *   Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ status: "degraded" })))
+     * )
+     *
+     * const program = Effect.gen(function*() {
+     *   const breaker = yield* CircuitBreaker.make({
+     *     tripPolicy: CircuitBreaker.consecutive(1),
+     *     openDuration: "30 seconds"
+     *   })
+     *   const client = degraded.pipe(
+     *     HttpClient.transformResponse(Effect.flatMap((response) =>
+     *       Effect.flatMap(response.json, (body) =>
+     *         typeof body === "object" && body !== null && "status" in body && body.status === "degraded"
+     *           ? Effect.fail(new Degraded())
+     *           : Effect.succeed(response))
+     *     )),
+     *     HttpClient.withCircuitBreaker({
+     *       breaker,
+     *       classify: (exit) =>
+     *         Option.exists(Exit.findErrorOption(exit), (error) => error._tag === "Degraded")
+     *           ? CircuitBreaker.failure()
+     *           : HttpClient.circuitBreakerClassifier(exit)
+     *     })
+     *   )
+     *
+     *   yield* Effect.flip(client.get("http://status.test/"))
+     *   const state = yield* breaker.state("http://status.test")
+     *   return state._tag
+     * }).pipe(Effect.scoped, Effect.provide(CircuitBreaker.layerStoreMemory()))
+     *
+     * await Effect.runPromise(program) // => "Open"
+     * ```
+     *
+     * @stability experimental
+     * @category circuit breaking
+     * @since 4.0.6
+     */
+    <E, R2 = never>(options: WithCircuitBreaker.Options<E, R2>): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E | CircuitBreaker.CircuitBreakerError, R | R2>;
+    /**
+     * Guards requests with a `CircuitBreaker`.
+     *
+     * **Details**
+     *
+     * Requests are keyed by origin unless `key` is set, and classified with
+     * `circuitBreakerClassifier` unless `classify` is set. A rejected request
+     * fails with `CircuitBreakerError` without reaching the wrapped client.
+     *
+     * Apply it after `withRateLimiter` and `retryTransient`, so the breaker sees
+     * one outcome per call and an open circuit skips the retry loop.
+     * `retryTransient` never retries a `CircuitBreakerError`. A custom `classify`
+     * can delegate the cases it doesn't handle to `circuitBreakerClassifier`.
+     *
+     * **Gotchas**
+     *
+     * - The breaker only sees the response headers. To count an error in the
+     *   body, lift it into the error channel below the breaker with
+     *   `transformResponse` and count it in `classify`.
+     * - `withRateLimiter` retries `429` without limit by default, which can hold
+     *   the probe slot for minutes. Set its `times`.
+     * - A rejected request has no client span. The rejection fails the caller's
+     *   span instead.
+     *
+     * **Example** (Guarding an API in the recommended order)
+     *
+     * ```ts import.meta.vitest
+     * import { Effect, Layer, Ref, Schedule } from "effect"
+     * import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
+     * import { CircuitBreaker, RateLimiter } from "effect/persistence"
+     *
+     * const program = Effect.gen(function*() {
+     *   const requests = yield* Ref.make(0)
+     *   // A dependency that always answers 503.
+     *   const unavailable = HttpClient.make((request) =>
+     *     Effect.as(Ref.update(requests, (n) => n + 1), HttpClientResponse.fromWeb(request, new Response(null, { status: 503 })))
+     *   )
+     *
+     *   const breaker = yield* CircuitBreaker.make({
+     *     tripPolicy: CircuitBreaker.consecutive(1),
+     *     openDuration: "30 seconds"
+     *   })
+     *   const client = unavailable.pipe(
+     *     HttpClient.withRateLimiter({
+     *       limiter: yield* RateLimiter.RateLimiter,
+     *       key: "inventory",
+     *       limit: 100,
+     *       window: "1 second",
+     *       times: 3
+     *     }),
+     *     HttpClient.retryTransient({ times: 2, schedule: Schedule.exponential("1 millis") }),
+     *     HttpClient.withCircuitBreaker({ breaker })
+     *   )
+     *
+     *   // Three attempts, then the breaker records one failure and opens.
+     *   yield* client.execute(HttpClientRequest.get("http://inventory.test/items"))
+     *   // Rejected before the retry loop starts, so no further request is sent.
+     *   const rejected = yield* Effect.flip(client.execute(HttpClientRequest.get("http://inventory.test/items")))
+     *
+     *   return [yield* Ref.get(requests), rejected._tag]
+     * }).pipe(
+     *   Effect.scoped,
+     *   Effect.provide(Layer.merge(
+     *     CircuitBreaker.layerStoreMemory(),
+     *     RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory))
+     *   ))
+     * )
+     *
+     * await Effect.runPromise(program) // => [3, "CircuitBreakerError"]
+     * ```
+     *
+     * **Example** (Counting an error in the body as a failure)
+     *
+     * This API answers `200` with `{ "status": "degraded" }` when it is failing.
+     *
+     * ```ts import.meta.vitest
+     * import { Data, Effect, Exit, Option } from "effect"
+     * import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http"
+     * import { CircuitBreaker } from "effect/persistence"
+     *
+     * class Degraded extends Data.TaggedError("Degraded") {}
+     *
+     * const degraded = HttpClient.make((request) =>
+     *   Effect.succeed(HttpClientResponse.fromWeb(request, Response.json({ status: "degraded" })))
+     * )
+     *
+     * const program = Effect.gen(function*() {
+     *   const breaker = yield* CircuitBreaker.make({
+     *     tripPolicy: CircuitBreaker.consecutive(1),
+     *     openDuration: "30 seconds"
+     *   })
+     *   const client = degraded.pipe(
+     *     HttpClient.transformResponse(Effect.flatMap((response) =>
+     *       Effect.flatMap(response.json, (body) =>
+     *         typeof body === "object" && body !== null && "status" in body && body.status === "degraded"
+     *           ? Effect.fail(new Degraded())
+     *           : Effect.succeed(response))
+     *     )),
+     *     HttpClient.withCircuitBreaker({
+     *       breaker,
+     *       classify: (exit) =>
+     *         Option.exists(Exit.findErrorOption(exit), (error) => error._tag === "Degraded")
+     *           ? CircuitBreaker.failure()
+     *           : HttpClient.circuitBreakerClassifier(exit)
+     *     })
+     *   )
+     *
+     *   yield* Effect.flip(client.get("http://status.test/"))
+     *   const state = yield* breaker.state("http://status.test")
+     *   return state._tag
+     * }).pipe(Effect.scoped, Effect.provide(CircuitBreaker.layerStoreMemory()))
+     *
+     * await Effect.runPromise(program) // => "Open"
+     * ```
+     *
+     * @stability experimental
+     * @category circuit breaking
+     * @since 4.0.6
+     */
+    <E, R, R2 = never>(self: HttpClient.With<E, R>, options: WithCircuitBreaker.Options<E, R2>): HttpClient.With<E | CircuitBreaker.CircuitBreakerError, R | R2>;
+};
+/**
+ * The default `withCircuitBreaker` classifier.
+ *
+ * **Details**
+ *
+ * - Failure: status 408, 500, 502, 503 or 504, returned or wrapped in a
+ *   `StatusCodeError`, and any `TransportError` or `Cause.TimeoutError`.
+ * - Success: any other response, including other 4xx, since the dependency
+ *   answered.
+ * - Ignored: status 429 (left to `withRateLimiter`), `EncodeError`,
+ *   `InvalidUrlError`, `DecodeError`, `EmptyBodyError`, unknown typed errors
+ *   and defects. HttpClient errors are typed, so a defect here is a bug in
+ *   the caller.
+ *
+ * When a cause holds several errors, a failure beats a success and a success
+ * beats an ignored outcome. A failure carries the longest `Retry-After` it
+ * saw. The result is an `Effect` only because parsing an HTTP-date
+ * `Retry-After` reads `Clock`.
+ *
+ * **Gotchas**
+ *
+ * `TransportError` also covers client-side refusals, which count as failures.
+ *
+ * @stability experimental
+ * @category circuit breaking
+ * @since 4.0.6
+ */
+export declare const circuitBreakerClassifier: <E>(exit: Exit.Exit<HttpClientResponse.HttpClientResponse, E>) => Effect.Effect<CircuitBreaker.Outcome>;
 /**
  * Performs an additional effect after a successful request.
  *
@@ -1007,12 +1430,20 @@ export declare const tapRequest: {
     <E, R, _, E2, R2>(self: HttpClient.With<E, R>, f: (a: HttpClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>): HttpClient.With<E | E2, R | R2>;
 };
 /**
- * Adds a `Ref` of cookies to the client for handling cookies across requests.
+ * Adds a `Ref` of stored cookies to the client for handling cookies across
+ * requests.
  *
  * **When to use**
  *
  * Use to add shared cookie storage to a client so response cookies are retained
- * and sent by later requests.
+ * and sent by later requests to a matching host, path, and scheme.
+ *
+ * **Details**
+ *
+ * Response cookies are merged into the ref with `Cookies.mergeIntoArray` for
+ * the response URL. Before each request, `Cookies.toRequestCookieHeader` selects
+ * the cookies for the request URL and sets them as the `cookie` header. Expiry
+ * uses the current `Clock`.
  *
  * @stability unstable
  * @category cookies
@@ -1020,31 +1451,47 @@ export declare const tapRequest: {
  */
 export declare const withCookiesRef: {
     /**
-     * Adds a `Ref` of cookies to the client for handling cookies across requests.
+     * Adds a `Ref` of stored cookies to the client for handling cookies across
+     * requests.
      *
      * **When to use**
      *
      * Use to add shared cookie storage to a client so response cookies are retained
-     * and sent by later requests.
+     * and sent by later requests to a matching host, path, and scheme.
+     *
+     * **Details**
+     *
+     * Response cookies are merged into the ref with `Cookies.mergeIntoArray` for
+     * the response URL. Before each request, `Cookies.toRequestCookieHeader` selects
+     * the cookies for the request URL and sets them as the `cookie` header. Expiry
+     * uses the current `Clock`.
      *
      * @stability unstable
      * @category cookies
      * @since 4.0.0
      */
-    (ref: Ref.Ref<Cookies.Cookies>): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R>;
+    (ref: Ref.Ref<ReadonlyArray<Cookies.Cookie>>): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R>;
     /**
-     * Adds a `Ref` of cookies to the client for handling cookies across requests.
+     * Adds a `Ref` of stored cookies to the client for handling cookies across
+     * requests.
      *
      * **When to use**
      *
      * Use to add shared cookie storage to a client so response cookies are retained
-     * and sent by later requests.
+     * and sent by later requests to a matching host, path, and scheme.
+     *
+     * **Details**
+     *
+     * Response cookies are merged into the ref with `Cookies.mergeIntoArray` for
+     * the response URL. Before each request, `Cookies.toRequestCookieHeader` selects
+     * the cookies for the request URL and sets them as the `cookie` header. Expiry
+     * uses the current `Clock`.
      *
      * @stability unstable
      * @category cookies
      * @since 4.0.0
      */
-    <E, R>(self: HttpClient.With<E, R>, ref: Ref.Ref<Cookies.Cookies>): HttpClient.With<E, R>;
+    <E, R>(self: HttpClient.With<E, R>, ref: Ref.Ref<ReadonlyArray<Cookies.Cookie>>): HttpClient.With<E, R>;
 };
 /**
  * Attaches the lifetime of the `HttpClientRequest` to a `Scope`.
@@ -1233,4 +1680,51 @@ export declare const SpanNameGenerator: Context.Reference<(request: HttpClientRe
  * @since 4.0.0
  */
 export declare const layerMergedContext: <E, R>(effect: Effect.Effect<HttpClient, E, R>) => Layer.Layer<HttpClient, E, R>;
+/**
+ * Returns `true` for an error that `retryTransient` retries by default: a
+ * timeout, a transport error, or a status code error with a transient response.
+ *
+ * **When to use**
+ *
+ * Use to classify failures the same way `retryTransient` does, for example in a
+ * custom retry policy or a circuit breaker.
+ *
+ * **Example** (Classifying client errors)
+ *
+ * ```ts import.meta.vitest
+ * import { Cause } from "effect"
+ * import { HttpClient, HttpClientError, HttpClientRequest } from "effect/http"
+ *
+ * const request = HttpClientRequest.get("https://example.com")
+ * const transportError = new HttpClientError.HttpClientError({
+ *   reason: new HttpClientError.TransportError({ request })
+ * })
+ *
+ * HttpClient.isTransientError(transportError) // => true
+ * HttpClient.isTransientError(new Cause.TimeoutError()) // => true
+ * HttpClient.isTransientError(new Error("boom")) // => false
+ * ```
+ *
+ * @see {@link isTransientResponse} for the response statuses it accepts
+ * @see {@link retryTransient} for the retry policy that uses it
+ * @stability unstable
+ * @category predicates
+ * @since 4.1.0
+ */
+export declare const isTransientError: (error: unknown) => boolean;
+/**
+ * Returns `true` for a response whose status `retryTransient` retries by
+ * default: 408, 429, 500, 502, 503 or 504.
+ *
+ * **When to use**
+ *
+ * Use to retry the same responses as `retryTransient` in a custom retry policy.
+ *
+ * @see {@link isTransientError} for the matching error predicate
+ * @see {@link retryTransient} for the retry policy that uses it
+ * @stability unstable
+ * @category predicates
+ * @since 4.1.0
+ */
+export declare const isTransientResponse: (response: HttpClientResponse.HttpClientResponse) => boolean;
 //# sourceMappingURL=HttpClient.d.ts.map