Code compiles and example booksSttpClient4Example works

build.sbt

@@ -2158,6 +2158,7 @@ lazy val examples: ProjectMatrix = (projectMatrix in file("examples"))
     picklerJson,
     prometheusMetrics,
     sttpClient,
+    sttpClient4,
     sttpMockServer,
     sttpStubServer,
     swaggerUiBundle,

client/sttp-client4/src/main/scala/sttp/tapir/client/sttp/EndpointToSttpClient.scala → client/sttp-client4/src/main/scala/sttp/tapir/client/sttp4/EndpointToSttpClient.scala

@@ -1,66 +1,61 @@
-package sttp.tapir.client.sttp
+package sttp.tapir.client.sttp4
 
 import sttp.capabilities.Streams
 import sttp.client4._
+import sttp.client4.ws.async
 import sttp.model._
-import sttp.shared.Identity
-import sttp.tapir.Codec.PlainCodec
 import sttp.tapir._
+import sttp.tapir.Codec.PlainCodec
 import sttp.tapir.client.ClientOutputParams
 import sttp.tapir.internal._
 import sttp.ws.WebSocket
 
-import java.io.ByteArrayInputStream
+import java.io.{ByteArrayInputStream, InputStream}
 import java.nio.ByteBuffer
 import scala.annotation.tailrec
 
 private[sttp] class EndpointToSttpClient[R](clientOptions: SttpClientOptions, wsToPipe: WebSocketToPipe[R])
     extends EndpointToSttpClientExtensions {
-  def toSttpRequest[A, E, O, I](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri]): A => I => Request[DecodeResult[Either[E, O]], R] = {
-    aParams => iParams =>
-      val (uri1, req1) =
-        setInputParams(
-          e.securityInput,
-          ParamsAsAny(aParams),
-          baseUri.getOrElse(Uri(None, None, Uri.EmptyPath, Nil, None)),
-          basicRequest.asInstanceOf[PartialAnyRequest]
-        )
-
-      val (uri2, req2) =
-        setInputParams(
-          e.input,
-          ParamsAsAny(iParams),
-          uri1,
-          req1
-        )
-
-      val req3: RequestT[Identity, _, _] =
-        req2.copy(
-          method = sttp.model.Method(e.method.getOrElse(Method.GET).method): Identity[Method],
-          uri = uri2: Identity[Uri]
-        )
-
-      val isWebSocket = bodyIsWebSocket(e.output)
-
-      def isSuccess(meta: ResponseMetadata) = if (isWebSocket) meta.code == webSocketSuccessStatusCode else meta.isSuccess
-
-      val responseAs = fromMetadata(
-        responseAsFromOutputs(e.errorOutput, isWebSocket = false),
-        ConditionalResponseAs(isSuccess, responseAsFromOutputs(e.output, isWebSocket))
-      ).mapWithMetadata { (body, meta) =>
-        val output = if (isSuccess(meta)) e.output else e.errorOutput
-        val params = clientOutputParams(output, body, meta)
-        params.map(_.asAny).map(p => if (isSuccess(meta)) Right(p) else Left(p))
-      }.map {
-        case DecodeResult.Error(o, e) =>
-          DecodeResult.Error(o, new IllegalArgumentException(s"Cannot decode from: $o, request: ${req3.method} ${req3.uri}", e))
-        case other => other
-      }
+  def toSttpRequest[A, E, O, I](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri]): A => I => Request[DecodeResult[Either[E, O]]] = { aParams => iParams =>
+    val (uri1, req1) =
+      setInputParams(
+        e.securityInput,
+        ParamsAsAny(aParams),
+        baseUri.getOrElse(Uri(None, None, Uri.EmptyPath, Nil, None)),
+        basicRequest.asInstanceOf[PartialAnyRequest]
+      )
+
+    val (uri2, req2) =
+      setInputParams(
+        e.input,
+        ParamsAsAny(iParams),
+        uri1,
+        req1
+      )
+
+    val req3 = req2.method(sttp.model.Method(e.method.getOrElse(Method.GET).method), uri2)
+
+    val isWebSocket = bodyIsWebSocket(e.output)
+
+    def isSuccess(meta: ResponseMetadata) = if (isWebSocket) meta.code == webSocketSuccessStatusCode else meta.isSuccess
+
+    val responseAs = fromMetadata(
+      responseAsFromOutputs(e.errorOutput, isWebSocket = false),
+      ConditionalResponseAs(isSuccess, responseAsFromOutputs(e.output, isWebSocket))
+    ).mapWithMetadata { (body, meta) =>
+      val output = if (isSuccess(meta)) e.output else e.errorOutput
+      val params = clientOutputParams(output, body, meta)
+      params.map(_.asAny).map(p => if (isSuccess(meta)) Right(p) else Left(p))
+    }.map {
+      case DecodeResult.Error(o, e) =>
+        DecodeResult.Error(o, new IllegalArgumentException(s"Cannot decode from: $o, request: ${req3.method} ${req3.uri}", e))
+      case other => other
+    }
 
-      req3.response(responseAs).asInstanceOf[Request[DecodeResult[Either[E, O]], R]]
+    req3.response(responseAs).asInstanceOf[Request[DecodeResult[Either[E, O]]]]
   }
 
-  private type PartialAnyRequest = PartialRequest[_, _]
+  private type PartialAnyRequest = PartialRequest[_]
 
   @tailrec
   private def setInputParams[I](
@@ -100,11 +95,11 @@ private[sttp] class EndpointToSttpClient[R](clientOptions: SttpClientOptions, ws
             EndpointIO.OneOfBodyVariant(_, Right(EndpointIO.StreamBodyWrapper(StreamBodyIO(streams, _, _, _, _)))) :: _,
             _
           ) =>
-        val req2 = req.streamBody(streams)(value.asInstanceOf[streams.BinaryStream])
+        val req2 = req.body(value.asInstanceOf[InputStream])
         (uri, req2)
       case EndpointIO.OneOfBody(Nil, _) => throw new RuntimeException("One of body without variants")
       case EndpointIO.StreamBodyWrapper(StreamBodyIO(streams, _, _, _, _)) =>
-        val req2 = req.streamBody(streams)(value.asInstanceOf[streams.BinaryStream])
+        val req2 = req.body(value.asInstanceOf[InputStream])
         (uri, req2)
       case EndpointIO.Header(name, codec, _) =>
         val req2 = codec
@@ -114,8 +109,11 @@ private[sttp] class EndpointToSttpClient[R](clientOptions: SttpClientOptions, ws
       case EndpointIO.Headers(codec, _) =>
         val headers = codec.encode(value)
         val req2 = headers.foldLeft(req) { case (r, h) =>
-          val replaceExisting = HeaderNames.ContentType.equalsIgnoreCase(h.name) || HeaderNames.ContentLength.equalsIgnoreCase(h.name)
-          r.header(h, replaceExisting)
+          val onDuplicate =
+            if (HeaderNames.ContentType.equalsIgnoreCase(h.name) || HeaderNames.ContentLength.equalsIgnoreCase(h.name))
+              DuplicateHeaderBehavior.Replace
+            else DuplicateHeaderBehavior.Add
+          r.header(h, onDuplicate)
         }
         (uri, req2)
       case EndpointIO.FixedHeader(h, _, _) =>
@@ -174,7 +172,7 @@ private[sttp] class EndpointToSttpClient[R](clientOptions: SttpClientOptions, ws
       case RawBodyType.FileBody             => req.body(encoded.file)
       case RawBodyType.InputStreamRangeBody => req.body(encoded.inputStream())
       case m: RawBodyType.MultipartBody =>
-        val parts: Seq[Part[RequestBody[Any]]] = (encoded: Seq[RawPart]).flatMap { p =>
+        val parts: Seq[Part[BasicBodyPart]] = (encoded: Seq[RawPart]).flatMap { p =>
           m.partType(p.name).map { partType =>
             // copying the name & body
             val sttpPart1 = partToSttpPart(p.asInstanceOf[Part[Any]], partType.asInstanceOf[RawBodyType[Any]])
@@ -193,7 +191,7 @@ private[sttp] class EndpointToSttpClient[R](clientOptions: SttpClientOptions, ws
     if (wasContentTypeAlreadySet) req2 else req2.contentType(codec.format.mediaType)
   }
 
-  private def partToSttpPart[T](p: Part[T], bodyType: RawBodyType[T]): Part[RequestBody[Any]] =
+  private def partToSttpPart[T](p: Part[T], bodyType: RawBodyType[T]): Part[BasicBodyPart] =
     bodyType match {
       case RawBodyType.StringBody(charset)  => multipart(p.name, p.body, charset.toString)
       case RawBodyType.ByteArrayBody        => multipart(p.name, p.body)
@@ -204,10 +202,10 @@ private[sttp] class EndpointToSttpClient[R](clientOptions: SttpClientOptions, ws
       case RawBodyType.MultipartBody(_, _)  => throw new IllegalArgumentException("Nested multipart bodies aren't supported")
     }
 
-  private def responseAsFromOutputs(out: EndpointOutput[_], isWebSocket: Boolean): ResponseAs[Any, Any] = {
+  private def responseAsFromOutputs(out: EndpointOutput[_], isWebSocket: Boolean): ResponseAs[Any] = {
     ((bodyIsStream(out), isWebSocket) match {
       case (Some(streams), _) => asStreamAlwaysUnsafe(streams)
-      case (_, true)          => asWebSocketAlwaysUnsafe
+      case (_, true)          => async.asWebSocketAlwaysUnsafe
       case (None, false) =>
         out.bodyType
           .map {
@@ -220,7 +218,7 @@ private[sttp] class EndpointToSttpClient[R](clientOptions: SttpClientOptions, ws
             case RawBodyType.MultipartBody(_, _)  => throw new IllegalArgumentException("Multipart bodies aren't supported in responses")
           }
           .getOrElse(ignore)
-    }).asInstanceOf[ResponseAs[Any, Any]]
+    }).asInstanceOf[ResponseAs[Any]]
   }
 
   private def bodyIsStream[I](out: EndpointOutput[I]): Option[Streams[_]] = {

client/sttp-client4/src/main/scala/sttp/tapir/client/sttp/SttpClientInterpreter.scala → client/sttp-client4/src/main/scala/sttp/tapir/client/sttp4/SttpClientInterpreter.scala

@@ -1,6 +1,6 @@
-package sttp.tapir.client.sttp
+package sttp.tapir.client.sttp4
 
-import sttp.client4.{Request, SttpBackend}
+import sttp.client4.{Backend, Request}
 import sttp.model.Uri
 import sttp.tapir.{DecodeResult, Endpoint, PublicEndpoint}
 
@@ -17,11 +17,12 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     * parameters: path, query, headers and body. The request is sent using the given backend, and the result of decoding the response (error
     * or success value) is returned.
     */
-  def toClient[F[_], I, E, O, R](e: PublicEndpoint[I, E, O, R], baseUri: Option[Uri], backend: SttpBackend[F, R])(implicit
+  def toClient[F[_], I, E, O, R](e: PublicEndpoint[I, E, O, R], baseUri: Option[Uri], backend: Backend[F])(implicit
       wsToPipe: WebSocketToPipe[R]
   ): I => F[DecodeResult[Either[E, O]]] = {
-    val req = toRequest(e, baseUri)
-    (i: I) => backend.responseMonad.map(backend.send(req(i)))(_.body)
+    (i: I) =>
+      val req = toRequest(e, baseUri)
+      backend.monad.map(req(i).send(backend))(_.body)
   }
 
   /** Interprets the public endpoint as a client call, using the given `baseUri` as the starting point to create the target uri. If
@@ -31,11 +32,11 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     * parameters: path, query, headers and body. The request is sent using the given backend, and the result (error or success value) is
     * returned. If decoding the result fails, a failed effect is returned instead.
     */
-  def toClientThrowDecodeFailures[F[_], I, E, O, R](e: PublicEndpoint[I, E, O, R], baseUri: Option[Uri], backend: SttpBackend[F, R])(
+  def toClientThrowDecodeFailures[F[_], I, E, O, R](e: PublicEndpoint[I, E, O, R], baseUri: Option[Uri], backend: Backend[F])(
       implicit wsToPipe: WebSocketToPipe[R]
   ): I => F[Either[E, O]] = {
     val req = toRequestThrowDecodeFailures(e, baseUri)
-    (i: I) => backend.responseMonad.map(backend.send(req(i)))(_.body)
+    (i: I) => backend.monad.map(req(i).send(backend))(_.body)
   }
 
   /** Interprets the public endpoint as a client call, using the given `baseUri` as the starting point to create the target uri. If
@@ -45,11 +46,11 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     * parameters: path, query, headers and body. The request is sent using the given backend, and the result (success value) is returned. If
     * decoding the result fails, or if the response corresponds to an error value, a failed effect is returned instead.
     */
-  def toClientThrowErrors[F[_], I, E, O, R](e: PublicEndpoint[I, E, O, R], baseUri: Option[Uri], backend: SttpBackend[F, R])(implicit
+  def toClientThrowErrors[F[_], I, E, O, R](e: PublicEndpoint[I, E, O, R], baseUri: Option[Uri], backend: Backend[F])(implicit
       wsToPipe: WebSocketToPipe[R]
   ): I => F[O] = {
     val req = toRequestThrowErrors(e, baseUri)
-    (i: I) => backend.responseMonad.map(backend.send(req(i)))(_.body)
+    (i: I) => backend.monad.map(req(i).send(backend))(_.body)
   }
 
   /** Interprets the public endpoint as a client call, using the given `baseUri` as the starting point to create the target uri. If
@@ -62,8 +63,9 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     */
   def toRequest[I, E, O, R](e: PublicEndpoint[I, E, O, R], baseUri: Option[Uri])(implicit
       wsToPipe: WebSocketToPipe[R]
-  ): I => Request[DecodeResult[Either[E, O]], R] =
+  ): I => Request[DecodeResult[Either[E, O]]] = {
     new EndpointToSttpClient(sttpClientOptions, wsToPipe).toSttpRequest(e, baseUri).apply(())
+  }
 
   /** Interprets the public endpoint as a client call, using the given `baseUri` as the starting point to create the target uri. If
     * `baseUri` is not provided, the request will be a relative one.
@@ -75,7 +77,7 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     */
   def toRequestThrowDecodeFailures[I, E, O, R](e: PublicEndpoint[I, E, O, R], baseUri: Option[Uri])(implicit
       wsToPipe: WebSocketToPipe[R]
-  ): I => Request[Either[E, O], R] =
+  ): I => Request[Either[E, O]] =
     i => new EndpointToSttpClient(sttpClientOptions, wsToPipe).toSttpRequest(e, baseUri).apply(()).apply(i).mapResponse(throwDecodeFailures)
 
   /** Interprets the public endpoint as a client call, using the given `baseUri` as the starting point to create the target uri. If
@@ -91,7 +93,7 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     */
   def toRequestThrowErrors[I, E, O, R](e: PublicEndpoint[I, E, O, R], baseUri: Option[Uri])(implicit
       wsToPipe: WebSocketToPipe[R]
-  ): I => Request[O, R] =
+  ): I => Request[O] =
     i =>
       new EndpointToSttpClient(sttpClientOptions, wsToPipe)
         .toSttpRequest(e, baseUri)
@@ -113,11 +115,11 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     * appropriate request parameters: path, query, headers and body. The request is sent using the given backend, and the result of decoding
     * the response (error or success value) is returned.
     */
-  def toSecureClient[F[_], A, I, E, O, R](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri], backend: SttpBackend[F, R])(implicit
+  def toSecureClient[F[_], A, I, E, O, R](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri], backend: Backend[F])(implicit
       wsToPipe: WebSocketToPipe[R]
   ): A => I => F[DecodeResult[Either[E, O]]] = {
     val req = toSecureRequest(e, baseUri)
-    (a: A) => (i: I) => backend.responseMonad.map(backend.send(req(a)(i)))(_.body)
+    (a: A) => (i: I) => backend.monad.map(backend.send(req(a)(i)))(_.body)
   }
 
   /** Interprets the secure endpoint as a client call, using the given `baseUri` as the starting point to create the target uri. If
@@ -127,11 +129,11 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     * appropriate request parameters: path, query, headers and body. The request is sent using the given backend, and the result (error or
     * success value) is returned. If decoding the result fails, a failed effect is returned instead.
     */
-  def toSecureClientThrowDecodeFailures[F[_], A, I, E, O, R](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri], backend: SttpBackend[F, R])(
+  def toSecureClientThrowDecodeFailures[F[_], A, I, E, O, R](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri], backend: Backend[F])(
       implicit wsToPipe: WebSocketToPipe[R]
   ): A => I => F[Either[E, O]] = {
     val req = toSecureRequestThrowDecodeFailures(e, baseUri)
-    (a: A) => (i: I) => backend.responseMonad.map(backend.send(req(a)(i)))(_.body)
+    (a: A) => (i: I) => backend.monad.map(backend.send(req(a)(i)))(_.body)
   }
 
   /** Interprets the secure endpoint as a client call, using the given `baseUri` as the starting point to create the target uri. If
@@ -142,11 +144,11 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     * value) is returned. If decoding the result fails, or if the response corresponds to an error value, a failed effect is returned
     * instead.
     */
-  def toSecureClientThrowErrors[F[_], A, I, E, O, R](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri], backend: SttpBackend[F, R])(implicit
+  def toSecureClientThrowErrors[F[_], A, I, E, O, R](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri], backend: Backend[F])(implicit
       wsToPipe: WebSocketToPipe[R]
   ): A => I => F[O] = {
     val req = toSecureRequestThrowErrors(e, baseUri)
-    (a: A) => (i: I) => backend.responseMonad.map(backend.send(req(a)(i)))(_.body)
+    (a: A) => (i: I) => backend.monad.map(backend.send(req(a)(i)))(_.body)
   }
 
   /** Interprets the secure endpoint as a client call, using the given `baseUri` as the starting point to create the target uri. If
@@ -159,7 +161,7 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     */
   def toSecureRequest[A, I, E, O, R](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri])(implicit
       wsToPipe: WebSocketToPipe[R]
-  ): A => I => Request[DecodeResult[Either[E, O]], R] =
+  ): A => I => Request[DecodeResult[Either[E, O]]] =
     new EndpointToSttpClient(sttpClientOptions, wsToPipe).toSttpRequest(e, baseUri)
 
   /** Interprets the secure endpoint as a client call, using the given `baseUri` as the starting point to create the target uri. If
@@ -172,7 +174,7 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     */
   def toSecureRequestThrowDecodeFailures[A, I, E, O, R](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri])(implicit
       wsToPipe: WebSocketToPipe[R]
-  ): A => I => Request[Either[E, O], R] =
+  ): A => I => Request[Either[E, O]] =
     a =>
       i =>
         new EndpointToSttpClient(sttpClientOptions, wsToPipe).toSttpRequest(e, baseUri).apply(a).apply(i).mapResponse(throwDecodeFailures)
@@ -190,7 +192,7 @@ trait SttpClientInterpreter extends SttpClientInterpreterExtensions {
     */
   def toSecureRequestThrowErrors[A, I, E, O, R](e: Endpoint[A, I, E, O, R], baseUri: Option[Uri])(implicit
       wsToPipe: WebSocketToPipe[R]
-  ): A => I => Request[O, R] =
+  ): A => I => Request[O] =
     a =>
       i =>
         new EndpointToSttpClient(sttpClientOptions, wsToPipe)

client/sttp-client4/src/main/scala/sttp/tapir/client/sttp/SttpClientOptions.scala → client/sttp-client4/src/main/scala/sttp/tapir/client/sttp4/SttpClientOptions.scala

@@ -1,4 +1,4 @@
-package sttp.tapir.client.sttp
+package sttp.tapir.client.sttp4
 
 import sttp.tapir.{Defaults, TapirFile}
 

client/sttp-client4/src/main/scala/sttp/tapir/client/sttp/WebSocketToPipe.scala → client/sttp-client4/src/main/scala/sttp/tapir/client/sttp4/WebSocketToPipe.scala

@@ -1,4 +1,4 @@
-package sttp.tapir.client.sttp
+package sttp.tapir.client.sttp4
 
 import sttp.capabilities.Streams
 import sttp.tapir.WebSocketBodyOutput

client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp/EndpointToSttpClientExtensions.scala → client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp4/EndpointToSttpClientExtensions.scala

@@ -1,8 +1,8 @@
-package sttp.tapir.client.sttp
+package sttp.tapir.client.sttp4
 
 import sttp.model.StatusCode
 
-private[sttp] trait EndpointToSttpClientExtensions { this: EndpointToSttpClient[_] =>
+private[sttp4] trait EndpointToSttpClientExtensions { this: EndpointToSttpClient[_] =>
 
   /** This needs to be platform-specific due to #2663, as on JS we don't get access to the 101 status code. */
   val webSocketSuccessStatusCode: StatusCode = StatusCode.Ok

client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp/SttpClientInterpreterExtensions.scala → client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp4/SttpClientInterpreterExtensions.scala

@@ -1,4 +1,4 @@
-package sttp.tapir.client.sttp
+package sttp.tapir.client.sttp4
 
 import sttp.client3.{FetchBackend, SttpBackend}
 import sttp.model.Uri

client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp/ws/fs2/TapirSttpClientFs2WebSockets.scala → client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp4/ws/fs2/TapirSttpClientFs2WebSockets.scala

@@ -1,4 +1,4 @@
-package sttp.tapir.client.sttp.ws.fs2
+package sttp.tapir.client.sttp4.ws.fs2
 
 import cats.effect.Concurrent
 import sttp.capabilities.WebSockets

client/sttp-client4/src/main/scalajvm/sttp/tapir/client/sttp/ws/fs2/WebSocketToFs2Pipe.scala → client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp4/ws/fs2/WebSocketToFs2Pipe.scala

@@ -1,4 +1,4 @@
-package sttp.tapir.client.sttp.ws.fs2
+package sttp.tapir.client.sttp4.ws.fs2
 
 import _root_.fs2._
 import cats.MonadError

client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp/ws/fs2/package.scala → client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp4/ws/fs2/package.scala

@@ -1,3 +1,3 @@
-package sttp.tapir.client.sttp.ws
+package sttp.tapir.client.sttp4.ws
 
 package object fs2 extends TapirSttpClientFs2WebSockets

client/sttp-client4/src/main/scalajvm/sttp/tapir/client/sttp/ws/zio/TapirSttpClientZioWebSockets.scala → client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp4/ws/zio/TapirSttpClientZioWebSockets.scala

@@ -1,4 +1,4 @@
-package sttp.tapir.client.sttp.ws.zio
+package sttp.tapir.client.sttp4.ws.zio
 
 import sttp.capabilities.WebSockets
 import sttp.capabilities.zio.ZioStreams

client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp/ws/zio/WebSocketToZioPipe.scala → client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp4/ws/zio/WebSocketToZioPipe.scala

@@ -1,4 +1,4 @@
-package sttp.tapir.client.sttp.ws.zio
+package sttp.tapir.client.sttp4.ws.zio
 
 import sttp.capabilities.WebSockets
 import sttp.capabilities.zio.ZioStreams

client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp/ws/zio/package.scala → client/sttp-client4/src/main/scalajs/sttp/tapir/client/sttp4/ws/zio/package.scala

@@ -1,3 +1,3 @@
-package sttp.tapir.client.sttp.ws
+package sttp.tapir.client.sttp4.ws
 
 package object zio extends TapirSttpClientZioWebSockets