@effect/platform 0.57.8 → 0.58.0

package/src/internal/{http/client.ts → httpClient.ts}

@@ -14,47 +14,47 @@ import * as Ref from "effect/Ref"
 import type * as Schedule from "effect/Schedule"
 import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
-import type * as Client from "../../Http/Client.js"
-import * as Error from "../../Http/ClientError.js"
-import type * as ClientRequest from "../../Http/ClientRequest.js"
-import type * as ClientResponse from "../../Http/ClientResponse.js"
-import * as Cookies from "../../Http/Cookies.js"
-import * as Headers from "../../Http/Headers.js"
-import * as Method from "../../Http/Method.js"
-import * as TraceContext from "../../Http/TraceContext.js"
-import * as UrlParams from "../../Http/UrlParams.js"
-import * as internalBody from "./body.js"
-import * as internalRequest from "./clientRequest.js"
-import * as internalResponse from "./clientResponse.js"
+import * as Cookies from "../Cookies.js"
+import * as Headers from "../Headers.js"
+import type * as Client from "../HttpClient.js"
+import * as Error from "../HttpClientError.js"
+import type * as ClientRequest from "../HttpClientRequest.js"
+import type * as ClientResponse from "../HttpClientResponse.js"
+import * as Method from "../HttpMethod.js"
+import * as TraceContext from "../HttpTraceContext.js"
+import * as UrlParams from "../UrlParams.js"
+import * as internalBody from "./httpBody.js"
+import * as internalRequest from "./httpClientRequest.js"
+import * as internalResponse from "./httpClientResponse.js"
 
 /** @internal */
 export const TypeId: Client.TypeId = Symbol.for(
-  "@effect/platform/Http/Client"
+  "@effect/platform/HttpClient"
 ) as Client.TypeId
 
 /** @internal */
-export const tag = Context.GenericTag<Client.Client.Default>("@effect/platform/Http/Client")
+export const tag = Context.GenericTag<Client.HttpClient.Default>("@effect/platform/HttpClient")
 
 /** @internal */
 export const currentTracerDisabledWhen = globalValue(
-  Symbol.for("@effect/platform/Http/Client/tracerDisabledWhen"),
-  () => FiberRef.unsafeMake<Predicate.Predicate<ClientRequest.ClientRequest>>(constFalse)
+  Symbol.for("@effect/platform/HttpClient/tracerDisabledWhen"),
+  () => FiberRef.unsafeMake<Predicate.Predicate<ClientRequest.HttpClientRequest>>(constFalse)
 )
 
 /** @internal */
 export const withTracerDisabledWhen = dual<
   (
-    predicate: Predicate.Predicate<ClientRequest.ClientRequest>
+    predicate: Predicate.Predicate<ClientRequest.HttpClientRequest>
   ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   <A, E, R>(
     effect: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<ClientRequest.ClientRequest>
+    predicate: Predicate.Predicate<ClientRequest.HttpClientRequest>
   ) => Effect.Effect<A, E, R>
 >(2, (self, pred) => Effect.locally(self, currentTracerDisabledWhen, pred))
 
 /** @internal */
 export const currentTracerPropagation = globalValue(
-  Symbol.for("@effect/platform/Http/Client/currentTracerPropagation"),
+  Symbol.for("@effect/platform/HttpClient/currentTracerPropagation"),
   () => FiberRef.unsafeMake(true)
 )
 
@@ -71,7 +71,7 @@ export const withTracerPropagation = dual<
 
 /** @internal */
 export const currentFetchOptions = globalValue(
-  Symbol.for("@effect/platform/Http/Client/currentFetchOptions"),
+  Symbol.for("@effect/platform/HttpClient/currentFetchOptions"),
   () => FiberRef.unsafeMake<RequestInit>({})
 )
 
@@ -93,16 +93,16 @@ const clientProto = {
   }
 }
 
-const isClient = (u: unknown): u is Client.Client<unknown, unknown, unknown> => Predicate.hasProperty(u, TypeId)
+const isClient = (u: unknown): u is Client.HttpClient<unknown, unknown, unknown> => Predicate.hasProperty(u, TypeId)
 
 /** @internal */
 export const make = <E2, R2, A, E, R>(
   execute: (
-    request: Effect.Effect<ClientRequest.ClientRequest, E2, R2>
+    request: Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => Effect.Effect<A, E, R>,
-  preprocess: Client.Client.Preprocess<E2, R2>
-): Client.Client<A, E, R> => {
-  function client(request: ClientRequest.ClientRequest) {
+  preprocess: Client.HttpClient.Preprocess<E2, R2>
+): Client.HttpClient<A, E, R> => {
+  function client(request: ClientRequest.HttpClientRequest) {
     return execute(preprocess(request))
   }
   Object.setPrototypeOf(client, clientProto)
@@ -114,12 +114,12 @@ export const make = <E2, R2, A, E, R>(
 /** @internal */
 export const makeDefault = (
   f: (
-    request: ClientRequest.ClientRequest,
+    request: ClientRequest.HttpClientRequest,
     url: URL,
     signal: AbortSignal,
-    fiber: Fiber.RuntimeFiber<ClientResponse.ClientResponse, Error.HttpClientError>
-  ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError, Scope.Scope>
-): Client.Client.Default =>
+    fiber: Fiber.RuntimeFiber<ClientResponse.HttpClientResponse, Error.HttpClientError>
+  ) => Effect.Effect<ClientResponse.HttpClientResponse, Error.HttpClientError, Scope.Scope>
+): Client.HttpClient.Default =>
   make((effect) =>
     Effect.flatMap(effect, (request) =>
       Effect.withFiberRuntime((fiber) => {
@@ -186,15 +186,15 @@ export const makeDefault = (
             }
           )
         )
-      })), Effect.succeed as Client.Client.Preprocess<never, never>)
+      })), Effect.succeed as Client.HttpClient.Preprocess<never, never>)
 
 /** @internal */
 export const Fetch = Context.GenericTag<Client.Fetch, typeof globalThis.fetch>(
-  "@effect/platform/Http/Client/Fetch"
+  "@effect/platform/HttpClient/Fetch"
 )
 
 /** @internal */
-export const fetch: Client.Client.Default = makeDefault((request, url, signal, fiber) => {
+export const fetch: Client.HttpClient.Default = makeDefault((request, url, signal, fiber) => {
   const context = fiber.getFiberRef(FiberRef.currentContext)
   const fetch: typeof globalThis.fetch = context.unsafeMap.get(Fetch.key) ?? globalThis.fetch
   const options = fiber.getFiberRef(currentFetchOptions)
@@ -239,16 +239,16 @@ export const transform = dual<
   <A, E, R, A1, E1, R1>(
     f: (
       effect: Effect.Effect<A, E, R>,
-      request: ClientRequest.ClientRequest
+      request: ClientRequest.HttpClientRequest
     ) => Effect.Effect<A1, E1, R1>
-  ) => (self: Client.Client<A, E, R>) => Client.Client<A1, E | E1, R | R1>,
+  ) => (self: Client.HttpClient<A, E, R>) => Client.HttpClient<A1, E | E1, R | R1>,
   <A, E, R, A1, E1, R1>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (
       effect: Effect.Effect<A, E, R>,
-      request: ClientRequest.ClientRequest
+      request: ClientRequest.HttpClientRequest
     ) => Effect.Effect<A1, E1, R1>
-  ) => Client.Client<A1, E | E1, R | R1>
+  ) => Client.HttpClient<A1, E | E1, R | R1>
 >(2, (self, f) =>
   make(
     Effect.flatMap((request) => f(self.execute(Effect.succeed(request)), request)),
@@ -260,12 +260,12 @@ export const filterStatus = dual<
   (
     f: (status: number) => boolean
   ) => <E, R>(
-    self: Client.Client.WithResponse<E, R>
-  ) => Client.Client.WithResponse<E | Error.ResponseError, R>,
+    self: Client.HttpClient.WithResponse<E, R>
+  ) => Client.HttpClient.WithResponse<E | Error.ResponseError, R>,
   <E, R>(
-    self: Client.Client.WithResponse<E, R>,
+    self: Client.HttpClient.WithResponse<E, R>,
     f: (status: number) => boolean
-  ) => Client.Client.WithResponse<E | Error.ResponseError, R>
+  ) => Client.HttpClient.WithResponse<E | Error.ResponseError, R>
 >(2, (self, f) =>
   transform(self, (effect, request) =>
     Effect.filterOrFail(
@@ -282,8 +282,8 @@ export const filterStatus = dual<
 
 /** @internal */
 export const filterStatusOk = <E, R>(
-  self: Client.Client.WithResponse<E, R>
-): Client.Client.WithResponse<E | Error.ResponseError, R> =>
+  self: Client.HttpClient.WithResponse<E, R>
+): Client.HttpClient.WithResponse<E | Error.ResponseError, R> =>
   transform(self, (effect, request) =>
     Effect.filterOrFail(
       effect,
@@ -298,7 +298,7 @@ export const filterStatusOk = <E, R>(
     ))
 
 /** @internal */
-export const fetchOk: Client.Client.Default = filterStatusOk(fetch)
+export const fetchOk: Client.HttpClient.Default = filterStatusOk(fetch)
 
 /** @internal */
 export const layer = Layer.succeed(tag, fetch)
@@ -307,11 +307,11 @@ export const layer = Layer.succeed(tag, fetch)
 export const transformResponse = dual<
   <A, E, R, A1, E1, R1>(
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
-  ) => (self: Client.Client<A, E, R>) => Client.Client<A1, E1, R1>,
+  ) => (self: Client.HttpClient<A, E, R>) => Client.HttpClient<A1, E1, R1>,
   <A, E, R, A1, E1, R1>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
-  ) => Client.Client<A1, E1, R1>
+  ) => Client.HttpClient<A1, E1, R1>
 >(2, (self, f) => make((request) => f(self.execute(request)), self.preprocess))
 
 /** @internal */
@@ -320,8 +320,8 @@ export const catchTag: {
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
   ): <A, R>(
-    self: Client.Client<A, E, R>
-  ) => Client.Client<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
+    self: Client.HttpClient<A, E, R>
+  ) => Client.HttpClient<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
   <
     R,
     E,
@@ -331,10 +331,10 @@ export const catchTag: {
     R1,
     E1
   >(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ): Client.Client<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
+  ): Client.HttpClient<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
 } = dual(
   3,
   <
@@ -346,10 +346,10 @@ export const catchTag: {
     E1,
     A1
   >(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ): Client.Client<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R> => transformResponse(self, Effect.catchTag(tag, f))
+  ): Client.HttpClient<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R> => transformResponse(self, Effect.catchTag(tag, f))
 )
 
 /** @internal */
@@ -374,8 +374,8 @@ export const catchTags: {
   >(
     cases: Cases
   ): <A, R>(
-    self: Client.Client<A, E, R>
-  ) => Client.Client<
+    self: Client.HttpClient<A, E, R>
+  ) => Client.HttpClient<
     | A
     | {
       [K in keyof Cases]: Cases[K] extends (
@@ -418,9 +418,9 @@ export const catchTags: {
           ]: never
         })
   >(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     cases: Cases
-  ): Client.Client<
+  ): Client.HttpClient<
     | A
     | {
       [K in keyof Cases]: Cases[K] extends (
@@ -465,9 +465,9 @@ export const catchTags: {
           ]: never
         })
   >(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     cases: Cases
-  ): Client.Client<
+  ): Client.HttpClient<
     | A
     | {
       [K in keyof Cases]: Cases[K] extends (
@@ -496,17 +496,17 @@ export const catchTags: {
 export const catchAll: {
   <E, A2, E2, R2>(
     f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): <A, R>(self: Client.Client<A, E, R>) => Client.Client<A2 | A, E2, R | R2>
+  ): <A, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A2 | A, E2, R | R2>
   <A, E, R, A2, E2, R2>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): Client.Client<A2 | A, E2, R | R2>
+  ): Client.HttpClient<A2 | A, E2, R | R2>
 } = dual(
   2,
   <A, E, R, A2, E2, R2>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): Client.Client<A2 | A, E2, R | R2> => transformResponse(self, Effect.catchAll(f))
+  ): Client.HttpClient<A2 | A, E2, R | R2> => transformResponse(self, Effect.catchAll(f))
 )
 
 /** @internal */
@@ -515,13 +515,13 @@ export const filterOrElse = dual<
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
   ) => <E, R>(
-    self: Client.Client<A, E, R>
-  ) => Client.Client<A | B, E2 | E, R2 | R>,
+    self: Client.HttpClient<A, E, R>
+  ) => Client.HttpClient<A | B, E2 | E, R2 | R>,
   <A, E, R, B, E2, R2>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ) => Client.Client<A | B, E2 | E, R2 | R>
+  ) => Client.HttpClient<A | B, E2 | E, R2 | R>
 >(3, (self, f, orElse) => transformResponse(self, Effect.filterOrElse(f, orElse)))
 
 /** @internal */
@@ -529,123 +529,123 @@ export const filterOrFail = dual<
   <A, E2>(
     f: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
-  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E2 | E, R>,
+  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E2 | E, R>,
   <A, E, R, E2>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
-  ) => Client.Client<A, E2 | E, R>
+  ) => Client.HttpClient<A, E2 | E, R>
 >(3, (self, f, orFailWith) => transformResponse(self, Effect.filterOrFail(f, orFailWith)))
 
 /** @internal */
 export const map = dual<
   <A, B>(
     f: (a: A) => B
-  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E, R>,
+  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B, E, R>,
   <A, E, R, B>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (a: A) => B
-  ) => Client.Client<B, E, R>
+  ) => Client.HttpClient<B, E, R>
 >(2, (self, f) => transformResponse(self, Effect.map(f)))
 
 /** @internal */
 export const mapEffect = dual<
   <A, B, E2, R2>(
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E | E2, R | R2>,
+  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B, E | E2, R | R2>,
   <A, E, R, B, E2, R2>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => Client.Client<B, E | E2, R | R2>
+  ) => Client.HttpClient<B, E | E2, R | R2>
 >(2, (self, f) => transformResponse(self, Effect.flatMap(f)))
 
 /** @internal */
 export const scoped = <A, E, R>(
-  self: Client.Client<A, E, R>
-): Client.Client<A, E, Exclude<R, Scope.Scope>> => transformResponse(self, Effect.scoped)
+  self: Client.HttpClient<A, E, R>
+): Client.HttpClient<A, E, Exclude<R, Scope.Scope>> => transformResponse(self, Effect.scoped)
 
 /** @internal */
 export const mapEffectScoped = dual<
   <A, B, E2, R2>(
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<B, E | E2, Exclude<R | R2, Scope.Scope>>,
+  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B, E | E2, Exclude<R | R2, Scope.Scope>>,
   <A, E, R, B, E2, R2>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ) => Client.Client<B, E | E2, Exclude<R | R2, Scope.Scope>>
+  ) => Client.HttpClient<B, E | E2, Exclude<R | R2, Scope.Scope>>
 >(2, (self, f) => scoped(mapEffect(self, f)))
 
 /** @internal */
 export const mapRequest = dual<
   (
-    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ) => <A, E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E, R>,
+    f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
+  ) => <A, E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E, R>,
   <A, E, R>(
-    self: Client.Client<A, E, R>,
-    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ) => Client.Client<A, E, R>
+    self: Client.HttpClient<A, E, R>,
+    f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
+  ) => Client.HttpClient<A, E, R>
 >(2, (self, f) => make(self.execute, (request) => Effect.map(self.preprocess(request), f)))
 
 /** @internal */
 export const mapRequestEffect = dual<
   <E2, R2>(
     f: (
-      a: ClientRequest.ClientRequest
-    ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
+      a: ClientRequest.HttpClientRequest
+    ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => <A, E, R>(
-    self: Client.Client<A, E, R>
-  ) => Client.Client<A, E | E2, R | R2>,
+    self: Client.HttpClient<A, E, R>
+  ) => Client.HttpClient<A, E | E2, R | R2>,
   <A, E, R, E2, R2>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (
-      a: ClientRequest.ClientRequest
-    ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
-  ) => Client.Client<A, E | E2, R | R2>
+      a: ClientRequest.HttpClientRequest
+    ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
+  ) => Client.HttpClient<A, E | E2, R | R2>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(self.preprocess(request), f)))
 
 /** @internal */
 export const mapInputRequest = dual<
   (
-    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ) => <A, E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E, R>,
+    f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
+  ) => <A, E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E, R>,
   <A, E, R>(
-    self: Client.Client<A, E, R>,
-    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
-  ) => Client.Client<A, E, R>
+    self: Client.HttpClient<A, E, R>,
+    f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
+  ) => Client.HttpClient<A, E, R>
 >(2, (self, f) => make(self.execute, (request) => self.preprocess(f(request))))
 
 /** @internal */
 export const mapInputRequestEffect = dual<
   <E2, R2>(
     f: (
-      a: ClientRequest.ClientRequest
-    ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
+      a: ClientRequest.HttpClientRequest
+    ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => <A, E, R>(
-    self: Client.Client<A, E, R>
-  ) => Client.Client<A, E | E2, R | R2>,
+    self: Client.HttpClient<A, E, R>
+  ) => Client.HttpClient<A, E | E2, R | R2>,
   <A, E, R, E2, R2>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (
-      a: ClientRequest.ClientRequest
-    ) => Effect.Effect<ClientRequest.ClientRequest, E2, R2>
-  ) => Client.Client<A, E | E2, R | R2>
+      a: ClientRequest.HttpClientRequest
+    ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
+  ) => Client.HttpClient<A, E | E2, R | R2>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(f(request), self.preprocess)))
 
 /** @internal */
 export const retry: {
   <R1, E extends E0, E0, B>(
     policy: Schedule.Schedule<B, E0, R1>
-  ): <A, R>(self: Client.Client<A, E, R>) => Client.Client<A, E, R1 | R>
+  ): <A, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E, R1 | R>
   <A, E extends E0, E0, R, R1, B>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     policy: Schedule.Schedule<B, E0, R1>
-  ): Client.Client<A, E, R | R1>
+  ): Client.HttpClient<A, E, R | R1>
 } = dual(
   2,
   <A, E extends E0, E0, R, R1, B>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     policy: Schedule.Schedule<B, E0, R1>
-  ): Client.Client<A, E, R | R1> => transformResponse(self, Effect.retry(policy))
+  ): Client.HttpClient<A, E, R | R1> => transformResponse(self, Effect.retry(policy))
 )
 
 /** @internal */
@@ -654,18 +654,18 @@ export const schemaFunction = dual<
     schema: Schema.Schema<SA, SI, SR>,
     options?: ParseOptions | undefined
   ) => <A, E, R>(
-    self: Client.Client<A, E, R>
+    self: Client.HttpClient<A, E, R>
   ) => (
-    request: ClientRequest.ClientRequest
+    request: ClientRequest.HttpClientRequest
   ) => (
     a: SA
   ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>,
   <A, E, R, SA, SI, SR>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     schema: Schema.Schema<SA, SI, SR>,
     options?: ParseOptions | undefined
   ) => (
-    request: ClientRequest.ClientRequest
+    request: ClientRequest.HttpClientRequest
   ) => (
     a: SA
   ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
@@ -696,43 +696,43 @@ export const schemaFunction = dual<
 export const tap = dual<
   <A, _, E2, R2>(
     f: (a: A) => Effect.Effect<_, E2, R2>
-  ) => <E, R>(self: Client.Client<A, E, R>) => Client.Client<A, E | E2, R | R2>,
+  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E | E2, R | R2>,
   <A, E, R, _, E2, R2>(
-    self: Client.Client<A, E, R>,
+    self: Client.HttpClient<A, E, R>,
     f: (a: A) => Effect.Effect<_, E2, R2>
-  ) => Client.Client<A, E | E2, R | R2>
+  ) => Client.HttpClient<A, E | E2, R | R2>
 >(2, (self, f) => transformResponse(self, Effect.tap(f)))
 
 /** @internal */
 export const tapRequest = dual<
   <_, E2, R2>(
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
+    f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>
   ) => <A, E, R>(
-    self: Client.Client<A, E, R>
-  ) => Client.Client<A, E | E2, R | R2>,
+    self: Client.HttpClient<A, E, R>
+  ) => Client.HttpClient<A, E | E2, R | R2>,
   <A, E, R, _, E2, R2>(
-    self: Client.Client<A, E, R>,
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<_, E2, R2>
-  ) => Client.Client<A, E | E2, R | R2>
+    self: Client.HttpClient<A, E, R>,
+    f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>
+  ) => Client.HttpClient<A, E | E2, R | R2>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.tap(self.preprocess(request), f)))
 
 /** @internal */
 export const withCookiesRef = dual<
   (
     ref: Ref.Ref<Cookies.Cookies>
-  ) => <E, R>(self: Client.Client.WithResponse<E, R>) => Client.Client.WithResponse<E, R>,
+  ) => <E, R>(self: Client.HttpClient.WithResponse<E, R>) => Client.HttpClient.WithResponse<E, R>,
   <E, R>(
-    self: Client.Client.WithResponse<E, R>,
+    self: Client.HttpClient.WithResponse<E, R>,
     ref: Ref.Ref<Cookies.Cookies>
-  ) => Client.Client.WithResponse<E, R>
+  ) => Client.HttpClient.WithResponse<E, R>
 >(
   2,
   <E, R>(
-    self: Client.Client.WithResponse<E, R>,
+    self: Client.HttpClient.WithResponse<E, R>,
     ref: Ref.Ref<Cookies.Cookies>
-  ): Client.Client.WithResponse<E, R> =>
+  ): Client.HttpClient.WithResponse<E, R> =>
     make(
-      (request: Effect.Effect<ClientRequest.ClientRequest, E, R>) =>
+      (request: Effect.Effect<ClientRequest.HttpClientRequest, E, R>) =>
         Effect.tap(
           self.execute(request),
           (response) => Ref.update(ref, (cookies) => Cookies.merge(cookies, response.cookies))

package/src/internal/httpClientError.ts

@@ -0,0 +1,6 @@
+import type * as Error from "../HttpClientError.js"
+
+/** @internal */
+export const TypeId: Error.TypeId = Symbol.for(
+  "@effect/platform/HttpClientError"
+) as Error.TypeId