From 8250215f180d315078111ad105a61e6e13115d4d Mon Sep 17 00:00:00 2001
From: Tim <hello@timsmart.co>
Date: Thu, 19 Dec 2024 10:24:39 +1300
Subject: [PATCH] remove generics from HttpClient tag service (#4169)

---
 .changeset/friendly-kiwis-end.md             |   8 +
 packages/platform/dtslint/HttpApiClient.ts   |   6 +-
 packages/platform/src/HttpClient.ts          | 188 ++++++++++---------
 packages/platform/src/internal/httpClient.ts | 160 ++++++++--------
 4 files changed, 190 insertions(+), 172 deletions(-)
 create mode 100644 .changeset/friendly-kiwis-end.md

diff --git a/.changeset/friendly-kiwis-end.md b/.changeset/friendly-kiwis-end.md
new file mode 100644
index 00000000000..cc25e61c21e
--- /dev/null
+++ b/.changeset/friendly-kiwis-end.md
@@ -0,0 +1,8 @@
+---
+"@effect/platform": minor
+---
+
+remove generics from HttpClient tag service
+
+Instead you can now use `HttpClient.With<E, R>` to specify the error and
+requirement types.
diff --git a/packages/platform/dtslint/HttpApiClient.ts b/packages/platform/dtslint/HttpApiClient.ts
index 7c4a8005b41..268366d9453 100644
--- a/packages/platform/dtslint/HttpApiClient.ts
+++ b/packages/platform/dtslint/HttpApiClient.ts
@@ -83,7 +83,7 @@ Effect.gen(function*() {
   const clientEndpointEffect = HttpApiClient.endpoint(TestApi, "Group1", "EndpointA")
   // $ExpectType never
   type _clientEndpointEffectError = Effect.Effect.Error<typeof clientEndpointEffect>
-  // $ExpectType "ApiErrorR" | "Group1ErrorR" | "EndpointAErrorR" | "EndpointASuccessR" | "EndpointASecurityErrorR" | "Group1SecurityErrorR" | "ApiSecurityErrorR" | HttpClient<HttpClientError, Scope>
+  // $ExpectType "ApiErrorR" | "Group1ErrorR" | "EndpointAErrorR" | "EndpointASuccessR" | "EndpointASecurityErrorR" | "Group1SecurityErrorR" | "ApiSecurityErrorR" | HttpClient
   type _clientEndpointEffectContext = Effect.Effect.Context<typeof clientEndpointEffect>
 
   const clientEndpoint = yield* clientEndpointEffect
@@ -100,7 +100,7 @@ Effect.gen(function*() {
   const clientGroupEffect = HttpApiClient.group(TestApi, "Group1")
   // $ExpectType never
   type _clientGroupEffectError = Effect.Effect.Error<typeof clientGroupEffect>
-  // $ExpectType "ApiErrorR" | "Group1ErrorR" | "EndpointAErrorR" | "EndpointASuccessR" | "EndpointBErrorR" | "EndpointBSuccessR" | "EndpointASecurityErrorR" | "EndpointBSecurityErrorR" | "Group1SecurityErrorR" | "ApiSecurityErrorR" | HttpClient<HttpClientError, Scope>
+  // $ExpectType "ApiErrorR" | "Group1ErrorR" | "EndpointAErrorR" | "EndpointASuccessR" | "EndpointBErrorR" | "EndpointBSuccessR" | "EndpointASecurityErrorR" | "EndpointBSecurityErrorR" | "Group1SecurityErrorR" | "ApiSecurityErrorR" | HttpClient
   type _clientGroupEffectContext = Effect.Effect.Context<typeof clientGroupEffect>
 
   const clientGroup = yield* clientGroupEffect
@@ -117,7 +117,7 @@ Effect.gen(function*() {
   const clientApiEffect = HttpApiClient.make(TestApi)
   // $ExpectType never
   type _clientApiEffectError = Effect.Effect.Error<typeof clientApiEffect>
-  // $ExpectType "ApiErrorR" | "Group1ErrorR" | "EndpointAErrorR" | "EndpointASuccessR" | "EndpointBErrorR" | "EndpointBSuccessR" | "EndpointASecurityErrorR" | "EndpointBSecurityErrorR" | "Group1SecurityErrorR" | "ApiSecurityErrorR" | "Group2ErrorR" | "EndpointCErrorR" | "EndpointCSuccessR" | HttpClient<HttpClientError, Scope>
+  // $ExpectType "ApiErrorR" | "Group1ErrorR" | "EndpointAErrorR" | "EndpointASuccessR" | "EndpointBErrorR" | "EndpointBSuccessR" | "EndpointASecurityErrorR" | "EndpointBSecurityErrorR" | "Group1SecurityErrorR" | "ApiSecurityErrorR" | "Group2ErrorR" | "EndpointCErrorR" | "EndpointCSuccessR" | HttpClient
   type _clientApiEffectContext = Effect.Effect.Context<typeof clientApiEffect>
 
   const clientApi = yield* clientApiEffect
diff --git a/packages/platform/src/HttpClient.ts b/packages/platform/src/HttpClient.ts
index c60b4a3f383..7b6f68b0eda 100644
--- a/packages/platform/src/HttpClient.ts
+++ b/packages/platform/src/HttpClient.ts
@@ -35,44 +35,52 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface HttpClient<E = Error.HttpClientError, R = Scope.Scope> extends Pipeable, Inspectable {
-  readonly [TypeId]: TypeId
-  readonly execute: (request: ClientRequest.HttpClientRequest) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
-
-  readonly get: (
-    url: string | URL,
-    options?: ClientRequest.Options.NoBody
-  ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
-  readonly head: (
-    url: string | URL,
-    options?: ClientRequest.Options.NoBody
-  ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
-  readonly post: (
-    url: string | URL,
-    options?: ClientRequest.Options.NoUrl
-  ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
-  readonly patch: (
-    url: string | URL,
-    options?: ClientRequest.Options.NoUrl
-  ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
-  readonly put: (
-    url: string | URL,
-    options?: ClientRequest.Options.NoUrl
-  ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
-  readonly del: (
-    url: string | URL,
-    options?: ClientRequest.Options.NoUrl
-  ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
-  readonly options: (
-    url: string | URL,
-    options?: ClientRequest.Options.NoUrl
-  ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
-}
+export interface HttpClient extends HttpClient.With<Error.HttpClientError, Scope.Scope> {}
 
 /**
  * @since 1.0.0
  */
 export declare namespace HttpClient {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface With<E, R> extends Pipeable, Inspectable {
+    readonly [TypeId]: TypeId
+    readonly execute: (
+      request: ClientRequest.HttpClientRequest
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+
+    readonly get: (
+      url: string | URL,
+      options?: ClientRequest.Options.NoBody
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+    readonly head: (
+      url: string | URL,
+      options?: ClientRequest.Options.NoBody
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+    readonly post: (
+      url: string | URL,
+      options?: ClientRequest.Options.NoUrl
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+    readonly patch: (
+      url: string | URL,
+      options?: ClientRequest.Options.NoUrl
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+    readonly put: (
+      url: string | URL,
+      options?: ClientRequest.Options.NoUrl
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+    readonly del: (
+      url: string | URL,
+      options?: ClientRequest.Options.NoUrl
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+    readonly options: (
+      url: string | URL,
+      options?: ClientRequest.Options.NoUrl
+    ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>
+  }
+
   /**
    * @since 1.0.0
    * @category models
@@ -203,11 +211,11 @@ export const options: (
 export const catchAll: {
   <E, E2, R2>(
     f: (e: E) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
-  ): <R>(self: HttpClient<E, R>) => HttpClient<E2, R2 | R>
+  ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E2, R2 | R>
   <E, R, A2, E2, R2>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     f: (e: E) => Effect.Effect<A2, E2, R2>
-  ): HttpClient<E2, R | R2>
+  ): HttpClient.With<E2, R | R2>
 } = internal.catchAll
 
 /**
@@ -218,12 +226,12 @@ export const catchTag: {
   <K extends E extends { _tag: string } ? E["_tag"] : never, E, E1, R1>(
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ): <R>(self: HttpClient<E, R>) => HttpClient<E1 | Exclude<E, { _tag: K }>, R1 | R>
+  ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E1 | Exclude<E, { _tag: K }>, R1 | R>
   <R, E, K extends E extends { _tag: string } ? E["_tag"] : never, R1, E1>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ): HttpClient<E1 | Exclude<E, { _tag: K }>, R1 | R>
+  ): HttpClient.With<E1 | Exclude<E, { _tag: K }>, R1 | R>
 } = internal.catchTag
 
 /**
@@ -243,8 +251,8 @@ export const catchTags: {
   >(
     cases: Cases
   ): <R>(
-    self: HttpClient<E, R>
-  ) => HttpClient<
+    self: HttpClient.With<E, R>
+  ) => HttpClient.With<
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
@@ -265,9 +273,9 @@ export const catchTags: {
       }
       & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string }>["_tag"]>]: never })
   >(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     cases: Cases
-  ): HttpClient<
+  ): HttpClient.With<
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
@@ -289,12 +297,12 @@ export const filterOrElse: {
   <E2, R2>(
     predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
     orElse: (response: ClientResponse.HttpClientResponse) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
-  ): <E, R>(self: HttpClient<E, R>) => HttpClient<E2 | E, R2 | R>
+  ): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E2 | E, R2 | R>
   <E, R, E2, R2>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
     orElse: (response: ClientResponse.HttpClientResponse) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
-  ): HttpClient<E2 | E, R2 | R>
+  ): HttpClient.With<E2 | E, R2 | R>
 } = internal.filterOrElse
 
 /**
@@ -307,12 +315,12 @@ export const filterOrFail: {
   <E2>(
     predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
     orFailWith: (response: ClientResponse.HttpClientResponse) => E2
-  ): <E, R>(self: HttpClient<E, R>) => HttpClient<E2 | E, R>
+  ): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E2 | E, R>
   <E, R, E2>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
     orFailWith: (response: ClientResponse.HttpClientResponse) => E2
-  ): HttpClient<E2 | E, R>
+  ): HttpClient.With<E2 | E, R>
 } = internal.filterOrFail
 
 /**
@@ -322,8 +330,8 @@ export const filterOrFail: {
  * @category filters
  */
 export const filterStatus: {
-  (f: (status: number) => boolean): <E, R>(self: HttpClient<E, R>) => HttpClient<E | Error.ResponseError, R>
-  <E, R>(self: HttpClient<E, R>, f: (status: number) => boolean): HttpClient<E | Error.ResponseError, R>
+  (f: (status: number) => boolean): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E | Error.ResponseError, R>
+  <E, R>(self: HttpClient.With<E, R>, f: (status: number) => boolean): HttpClient.With<E | Error.ResponseError, R>
 } = internal.filterStatus
 
 /**
@@ -332,7 +340,7 @@ export const filterStatus: {
  * @since 1.0.0
  * @category filters
  */
-export const filterStatusOk: <E, R>(self: HttpClient<E, R>) => HttpClient<E | Error.ResponseError, R> =
+export const filterStatusOk: <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E | Error.ResponseError, R> =
   internal.filterStatusOk
 
 /**
@@ -344,7 +352,7 @@ export const makeWith: <E2, R2, E, R>(
     request: Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>,
   preprocess: HttpClient.Preprocess<E2, R2>
-) => HttpClient<E, R> = internal.makeWith
+) => HttpClient.With<E, R> = internal.makeWith
 
 /**
  * @since 1.0.0
@@ -369,14 +377,14 @@ export const transform: {
       effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>,
       request: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ): (self: HttpClient<E, R>) => HttpClient<E | E1, R | R1>
+  ): (self: HttpClient.With<E, R>) => HttpClient.With<E | E1, R | R1>
   <E, R, E1, R1>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     f: (
       effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>,
       request: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ): HttpClient<E | E1, R | R1>
+  ): HttpClient.With<E | E1, R | R1>
 } = internal.transform
 
 /**
@@ -388,13 +396,13 @@ export const transformResponse: {
     f: (
       effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>
     ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ): (self: HttpClient<E, R>) => HttpClient<E1, R1>
+  ): (self: HttpClient.With<E, R>) => HttpClient.With<E1, R1>
   <E, R, E1, R1>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     f: (
       effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>
     ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ): HttpClient<E1, R1>
+  ): HttpClient.With<E1, R1>
 } = internal.transformResponse
 
 /**
@@ -406,11 +414,11 @@ export const transformResponse: {
 export const mapRequest: {
   (
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ): <E, R>(self: HttpClient<E, R>) => HttpClient<E, R>
+  ): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R>
   <E, R>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ): HttpClient<E, R>
+  ): HttpClient.With<E, R>
 } = internal.mapRequest
 
 /**
@@ -422,11 +430,11 @@ export const mapRequest: {
 export const mapRequestEffect: {
   <E2, R2>(
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ): <E, R>(self: HttpClient<E, R>) => HttpClient<E | E2, R | R2>
+  ): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E | E2, R | R2>
   <E, R, E2, R2>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ): HttpClient<E | E2, R | R2>
+  ): HttpClient.With<E | E2, R | R2>
 } = internal.mapRequestEffect
 
 /**
@@ -438,11 +446,11 @@ export const mapRequestEffect: {
 export const mapRequestInput: {
   (
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ): <E, R>(self: HttpClient<E, R>) => HttpClient<E, R>
+  ): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R>
   <E, R>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ): HttpClient<E, R>
+  ): HttpClient.With<E, R>
 } = internal.mapRequestInput
 
 /**
@@ -454,11 +462,11 @@ export const mapRequestInput: {
 export const mapRequestInputEffect: {
   <E2, R2>(
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ): <E, R>(self: HttpClient<E, R>) => HttpClient<E | E2, R | R2>
+  ): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E | E2, R | R2>
   <E, R, E2, R2>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ): HttpClient<E | E2, R | R2>
+  ): HttpClient.With<E | E2, R | R2>
 } = internal.mapRequestInputEffect
 
 /**
@@ -470,7 +478,7 @@ export declare namespace Retry {
    * @since 1.0.0
    * @category error handling
    */
-  export type Return<R, E, O extends Effect.Retry.Options<E>> = HttpClient<
+  export type Return<R, E, O extends Effect.Retry.Options<E>> = HttpClient.With<
     | (O extends { schedule: Schedule.Schedule<infer _O, infer _I, infer _R> } ? E
       : O extends { until: Predicate.Refinement<E, infer E2> } ? E2
       : E)
@@ -490,10 +498,12 @@ export declare namespace Retry {
  * @category error handling
  */
 export const retry: {
-  <E, O extends Effect.Retry.Options<E>>(options: O): <R>(self: HttpClient<E, R>) => Retry.Return<R, E, O>
-  <B, E, R1>(policy: Schedule.Schedule<B, NoInfer<E>, R1>): <R>(self: HttpClient<E, R>) => HttpClient<E, R1 | R>
-  <E, R, O extends Effect.Retry.Options<E>>(self: HttpClient<E, R>, options: O): Retry.Return<R, E, O>
-  <E, R, B, R1>(self: HttpClient<E, R>, policy: Schedule.Schedule<B, E, R1>): HttpClient<E, R1 | R>
+  <E, O extends Effect.Retry.Options<E>>(options: O): <R>(self: HttpClient.With<E, R>) => Retry.Return<R, E, O>
+  <B, E, R1>(
+    policy: Schedule.Schedule<B, NoInfer<E>, R1>
+  ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R1 | R>
+  <E, R, O extends Effect.Retry.Options<E>>(self: HttpClient.With<E, R>, options: O): Retry.Return<R, E, O>
+  <E, R, B, R1>(self: HttpClient.With<E, R>, policy: Schedule.Schedule<B, E, R1>): HttpClient.With<E, R1 | R>
 } = internal.retry
 
 /**
@@ -512,15 +522,15 @@ export const retryTransient: {
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
-  ): <R>(self: HttpClient<E, R>) => HttpClient<E, R1 | R>
+  ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R1 | R>
   <E, R, B, R1 = never>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     options: {
       readonly while?: Predicate.Predicate<NoInfer<E>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
-  ): HttpClient<E, R1 | R>
+  ): HttpClient.With<E, R1 | R>
 } = internal.retryTransient
 
 /**
@@ -532,11 +542,11 @@ export const retryTransient: {
 export const tap: {
   <_, E2, R2>(
     f: (response: ClientResponse.HttpClientResponse) => Effect.Effect<_, E2, R2>
-  ): <E, R>(self: HttpClient<E, R>) => HttpClient<E | E2, R | R2>
+  ): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E | E2, R | R2>
   <E, R, _, E2, R2>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     f: (response: ClientResponse.HttpClientResponse) => Effect.Effect<_, E2, R2>
-  ): HttpClient<E | E2, R | R2>
+  ): HttpClient.With<E | E2, R | R2>
 } = internal.tap
 
 /**
@@ -548,11 +558,11 @@ export const tap: {
 export const tapRequest: {
   <_, E2, R2>(
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>
-  ): <E, R>(self: HttpClient<E, R>) => HttpClient<E | E2, R | R2>
+  ): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E | E2, R | R2>
   <E, R, _, E2, R2>(
-    self: HttpClient<E, R>,
+    self: HttpClient.With<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>
-  ): HttpClient<E | E2, R | R2>
+  ): HttpClient.With<E | E2, R | R2>
 } = internal.tapRequest
 
 /**
@@ -562,8 +572,8 @@ export const tapRequest: {
  * @category cookies
  */
 export const withCookiesRef: {
-  (ref: Ref<Cookies>): <E, R>(self: HttpClient<E, R>) => HttpClient<E, R>
-  <E, R>(self: HttpClient<E, R>, ref: Ref<Cookies>): HttpClient<E, R>
+  (ref: Ref<Cookies>): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R>
+  <E, R>(self: HttpClient.With<E, R>, ref: Ref<Cookies>): HttpClient.With<E, R>
 } = internal.withCookiesRef
 
 /**
@@ -573,8 +583,8 @@ export const withCookiesRef: {
  * @category redirects
  */
 export const followRedirects: {
-  (maxRedirects?: number | undefined): <E, R>(self: HttpClient<E, R>) => HttpClient<E, R>
-  <E, R>(self: HttpClient<E, R>, maxRedirects?: number | undefined): HttpClient<E, R>
+  (maxRedirects?: number | undefined): <E, R>(self: HttpClient.With<E, R>) => HttpClient.With<E, R>
+  <E, R>(self: HttpClient.With<E, R>, maxRedirects?: number | undefined): HttpClient.With<E, R>
 } = internal.followRedirects
 
 /**
diff --git a/packages/platform/src/internal/httpClient.ts b/packages/platform/src/internal/httpClient.ts
index 1c684b7b5e7..0a62df595bb 100644
--- a/packages/platform/src/internal/httpClient.ts
+++ b/packages/platform/src/internal/httpClient.ts
@@ -100,9 +100,9 @@ const ClientProto = {
   }
 }
 
-const isClient = (u: unknown): u is Client.HttpClient<unknown, unknown> => Predicate.hasProperty(u, TypeId)
+const isClient = (u: unknown): u is Client.HttpClient.With<unknown, unknown> => Predicate.hasProperty(u, TypeId)
 
-interface HttpClientImpl<E, R> extends Client.HttpClient<E, R> {
+interface HttpClientImpl<E, R> extends Client.HttpClient.With<E, R> {
   readonly preprocess: Client.HttpClient.Preprocess<E, R>
   readonly postprocess: Client.HttpClient.Postprocess<E, R>
 }
@@ -113,7 +113,7 @@ export const makeWith = <E2, R2, E, R>(
     request: Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => Effect.Effect<ClientResponse.HttpClientResponse, E, R>,
   preprocess: Client.HttpClient.Preprocess<E2, R2>
-): Client.HttpClient<E, R> => {
+): Client.HttpClient.With<E, R> => {
   const self = Object.create(ClientProto)
   self.preprocess = preprocess
   self.postprocess = postprocess
@@ -226,14 +226,14 @@ export const transform = dual<
       effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>,
       request: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ) => (self: Client.HttpClient<E, R>) => Client.HttpClient<E | E1, R | R1>,
+  ) => (self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E | E1, R | R1>,
   <E, R, E1, R1>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (
       effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>,
       request: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ) => Client.HttpClient<E | E1, R | R1>
+  ) => Client.HttpClient.With<E | E1, R | R1>
 >(2, (self, f) => {
   const client = self as HttpClientImpl<any, any>
   return makeWith(
@@ -247,18 +247,18 @@ export const filterStatus = dual<
   (
     f: (status: number) => boolean
   ) => <E, R>(
-    self: Client.HttpClient<E, R>
-  ) => Client.HttpClient<E | Error.ResponseError, R>,
+    self: Client.HttpClient.With<E, R>
+  ) => Client.HttpClient.With<E | Error.ResponseError, R>,
   <E, R>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (status: number) => boolean
-  ) => Client.HttpClient<E | Error.ResponseError, R>
+  ) => Client.HttpClient.With<E | Error.ResponseError, R>
 >(2, (self, f) => transformResponse(self, Effect.flatMap(internalResponse.filterStatus(f))))
 
 /** @internal */
 export const filterStatusOk = <E, R>(
-  self: Client.HttpClient<E, R>
-): Client.HttpClient<E | Error.ResponseError, R> =>
+  self: Client.HttpClient.With<E, R>
+): Client.HttpClient.With<E | Error.ResponseError, R> =>
   transformResponse(self, Effect.flatMap(internalResponse.filterStatusOk))
 
 /** @internal */
@@ -267,13 +267,13 @@ export const transformResponse = dual<
     f: (
       effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>
     ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ) => (self: Client.HttpClient<E, R>) => Client.HttpClient<E1, R1>,
+  ) => (self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E1, R1>,
   <E, R, E1, R1>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (
       effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R>
     ) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ) => Client.HttpClient<E1, R1>
+  ) => Client.HttpClient.With<E1, R1>
 >(2, (self, f) => {
   const client = self as HttpClientImpl<any, any>
   return makeWith((request) => f(client.postprocess(request)), client.preprocess)
@@ -284,7 +284,7 @@ export const catchTag: {
   <K extends E extends { _tag: string } ? E["_tag"] : never, E, E1, R1>(
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E1 | Exclude<E, { _tag: K }>, R1 | R>
+  ): <R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E1 | Exclude<E, { _tag: K }>, R1 | R>
   <
     R,
     E,
@@ -292,10 +292,10 @@ export const catchTag: {
     R1,
     E1
   >(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ): Client.HttpClient<E1 | Exclude<E, { _tag: K }>, R1 | R>
+  ): Client.HttpClient.With<E1 | Exclude<E, { _tag: K }>, R1 | R>
 } = dual(
   3,
   <
@@ -305,10 +305,10 @@ export const catchTag: {
     R1,
     E1
   >(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<ClientResponse.HttpClientResponse, E1, R1>
-  ): Client.HttpClient<E1 | Exclude<E, { _tag: K }>, R1 | R> => transformResponse(self, Effect.catchTag(tag, f))
+  ): Client.HttpClient.With<E1 | Exclude<E, { _tag: K }>, R1 | R> => transformResponse(self, Effect.catchTag(tag, f))
 )
 
 /** @internal */
@@ -332,7 +332,7 @@ export const catchTags: {
         })
   >(
     cases: Cases
-  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<
+  ): <R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends (
@@ -367,9 +367,9 @@ export const catchTags: {
           ]: never
         })
   >(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     cases: Cases
-  ): Client.HttpClient<
+  ): Client.HttpClient.With<
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends (
@@ -406,9 +406,9 @@ export const catchTags: {
           ]: never
         })
   >(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     cases: Cases
-  ): Client.HttpClient<
+  ): Client.HttpClient.With<
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends (
@@ -430,17 +430,17 @@ export const catchTags: {
 export const catchAll: {
   <E, E2, R2>(
     f: (e: E) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
-  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E2, R | R2>
+  ): <R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E2, R | R2>
   <E, R, E2, R2>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (e: E) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
-  ): Client.HttpClient<E2, R | R2>
+  ): Client.HttpClient.With<E2, R | R2>
 } = dual(
   2,
   <E, R, E2, R2>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (e: E) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
-  ): Client.HttpClient<E2, R | R2> => transformResponse(self, Effect.catchAll(f))
+  ): Client.HttpClient.With<E2, R | R2> => transformResponse(self, Effect.catchAll(f))
 )
 
 /** @internal */
@@ -449,13 +449,13 @@ export const filterOrElse: {
     predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
     orElse: (response: ClientResponse.HttpClientResponse) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
   ): <E, R>(
-    self: Client.HttpClient<E, R>
-  ) => Client.HttpClient<E2 | E, R2 | R>
+    self: Client.HttpClient.With<E, R>
+  ) => Client.HttpClient.With<E2 | E, R2 | R>
   <E, R, E2, R2>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
     orElse: (response: ClientResponse.HttpClientResponse) => Effect.Effect<ClientResponse.HttpClientResponse, E2, R2>
-  ): Client.HttpClient<E2 | E, R2 | R>
+  ): Client.HttpClient.With<E2 | E, R2 | R>
 } = dual(3, (self, f, orElse) => transformResponse(self, Effect.filterOrElse(f, orElse)))
 
 /** @internal */
@@ -463,23 +463,23 @@ export const filterOrFail: {
   <E2>(
     predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
     orFailWith: (response: ClientResponse.HttpClientResponse) => E2
-  ): <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E2 | E, R>
+  ): <E, R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E2 | E, R>
   <E, R, E2>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     predicate: Predicate.Predicate<ClientResponse.HttpClientResponse>,
     orFailWith: (response: ClientResponse.HttpClientResponse) => E2
-  ): Client.HttpClient<E2 | E, R>
+  ): Client.HttpClient.With<E2 | E, R>
 } = dual(3, (self, f, orFailWith) => transformResponse(self, Effect.filterOrFail(f, orFailWith)))
 
 /** @internal */
 export const mapRequest = dual<
   (
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R>,
+  ) => <E, R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E, R>,
   <E, R>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ) => Client.HttpClient<E, R>
+  ) => Client.HttpClient.With<E, R>
 >(2, (self, f) => {
   const client = self as HttpClientImpl<any, any>
   return makeWith(client.postprocess, (request) => Effect.map(client.preprocess(request), f))
@@ -492,14 +492,14 @@ export const mapRequestEffect = dual<
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => <E, R>(
-    self: Client.HttpClient<E, R>
-  ) => Client.HttpClient<E | E2, R | R2>,
+    self: Client.HttpClient.With<E, R>
+  ) => Client.HttpClient.With<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ) => Client.HttpClient<E | E2, R | R2>
+  ) => Client.HttpClient.With<E | E2, R | R2>
 >(2, (self, f) => {
   const client = self as HttpClientImpl<any, any>
   return makeWith(client.postprocess as any, (request) => Effect.flatMap(client.preprocess(request), f))
@@ -509,11 +509,11 @@ export const mapRequestEffect = dual<
 export const mapRequestInput = dual<
   (
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R>,
+  ) => <E, R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E, R>,
   <E, R>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
-  ) => Client.HttpClient<E, R>
+  ) => Client.HttpClient.With<E, R>
 >(2, (self, f) => {
   const client = self as HttpClientImpl<any, any>
   return makeWith(client.postprocess, (request) => client.preprocess(f(request)))
@@ -526,14 +526,14 @@ export const mapRequestInputEffect = dual<
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => <E, R>(
-    self: Client.HttpClient<E, R>
-  ) => Client.HttpClient<E | E2, R | R2>,
+    self: Client.HttpClient.With<E, R>
+  ) => Client.HttpClient.With<E | E2, R | R2>,
   <E, R, E2, R2>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
-  ) => Client.HttpClient<E | E2, R | R2>
+  ) => Client.HttpClient.With<E | E2, R | R2>
 >(2, (self, f) => {
   const client = self as HttpClientImpl<any, any>
   return makeWith(client.postprocess as any, (request) => Effect.flatMap(f(request), client.preprocess))
@@ -543,24 +543,24 @@ export const mapRequestInputEffect = dual<
 export const retry: {
   <E, O extends Effect.Retry.Options<E>>(
     options: O
-  ): <R>(self: Client.HttpClient<E, R>) => Client.Retry.Return<R, E, O>
+  ): <R>(self: Client.HttpClient.With<E, R>) => Client.Retry.Return<R, E, O>
   <B, E, R1>(
     policy: Schedule.Schedule<B, NoInfer<E>, R1>
-  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R1 | R>
+  ): <R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E, R1 | R>
   <E, R, O extends Effect.Retry.Options<E>>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     options: O
   ): Client.Retry.Return<R, E, O>
   <E, R, B, R1>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     policy: Schedule.Schedule<B, E, R1>
-  ): Client.HttpClient<E, R1 | R>
+  ): Client.HttpClient.With<E, R1 | R>
 } = dual(
   2,
   <E extends E0, E0, R, R1, B>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     policy: Schedule.Schedule<B, E0, R1>
-  ): Client.HttpClient<E, R | R1> => transformResponse(self, Effect.retry(policy))
+  ): Client.HttpClient.With<E, R | R1> => transformResponse(self, Effect.retry(policy))
 )
 
 /** @internal */
@@ -571,25 +571,25 @@ export const retryTransient: {
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
-  ): <R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R1 | R>
+  ): <R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E, R1 | R>
   <E, R, B, R1 = never>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     options: {
       readonly while?: Predicate.Predicate<NoInfer<E>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
-  ): Client.HttpClient<E, R1 | R>
+  ): Client.HttpClient.With<E, R1 | R>
 } = dual(
   2,
   <E extends E0, E0, R, B, R1 = never>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     options: {
       readonly while?: Predicate.Predicate<NoInfer<E>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<E>, R1>
       readonly times?: number
     } | Schedule.Schedule<B, NoInfer<E>, R1>
-  ): Client.HttpClient<E, R | R1> =>
+  ): Client.HttpClient.With<E, R | R1> =>
     transformResponse(
       self,
       Effect.retry({
@@ -614,11 +614,11 @@ const isTransientHttpError = (error: unknown) =>
 export const tap = dual<
   <_, E2, R2>(
     f: (response: ClientResponse.HttpClientResponse) => Effect.Effect<_, E2, R2>
-  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E | E2, R | R2>,
+  ) => <E, R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E | E2, R | R2>,
   <E, R, _, E2, R2>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (response: ClientResponse.HttpClientResponse) => Effect.Effect<_, E2, R2>
-  ) => Client.HttpClient<E | E2, R | R2>
+  ) => Client.HttpClient.With<E | E2, R | R2>
 >(2, (self, f) => transformResponse(self, Effect.tap(f)))
 
 /** @internal */
@@ -626,12 +626,12 @@ export const tapRequest = dual<
   <_, E2, R2>(
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>
   ) => <E, R>(
-    self: Client.HttpClient<E, R>
-  ) => Client.HttpClient<E | E2, R | R2>,
+    self: Client.HttpClient.With<E, R>
+  ) => Client.HttpClient.With<E | E2, R | R2>,
   <E, R, _, E2, R2>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>
-  ) => Client.HttpClient<E | E2, R | R2>
+  ) => Client.HttpClient.With<E | E2, R | R2>
 >(2, (self, f) => {
   const client = self as HttpClientImpl<any, any>
   return makeWith(client.postprocess as any, (request) => Effect.tap(client.preprocess(request), f))
@@ -641,17 +641,17 @@ export const tapRequest = dual<
 export const withCookiesRef = dual<
   (
     ref: Ref.Ref<Cookies.Cookies>
-  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R>,
+  ) => <E, R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E, R>,
   <E, R>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     ref: Ref.Ref<Cookies.Cookies>
-  ) => Client.HttpClient<E, R>
+  ) => Client.HttpClient.With<E, R>
 >(
   2,
   <E, R>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     ref: Ref.Ref<Cookies.Cookies>
-  ): Client.HttpClient<E, R> => {
+  ): Client.HttpClient.With<E, R> => {
     const client = self as HttpClientImpl<E, R>
     return makeWith(
       (request: Effect.Effect<ClientRequest.HttpClientRequest, E, R>) =>
@@ -676,15 +676,15 @@ export const withCookiesRef = dual<
 export const followRedirects = dual<
   (
     maxRedirects?: number | undefined
-  ) => <E, R>(self: Client.HttpClient<E, R>) => Client.HttpClient<E, R>,
+  ) => <E, R>(self: Client.HttpClient.With<E, R>) => Client.HttpClient.With<E, R>,
   <E, R>(
-    self: Client.HttpClient<E, R>,
+    self: Client.HttpClient.With<E, R>,
     maxRedirects?: number | undefined
-  ) => Client.HttpClient<E, R>
+  ) => Client.HttpClient.With<E, R>
 >((args) => isClient(args[0]), <E, R>(
-  self: Client.HttpClient<E, R>,
+  self: Client.HttpClient.With<E, R>,
   maxRedirects?: number | undefined
-): Client.HttpClient<E, R> => {
+): Client.HttpClient.With<E, R> => {
   const client = self as HttpClientImpl<E, R>
   return makeWith(
     (request) => {