Fix docs

Author: adamw

generated-doc/out/client/play.md

@@ -0,0 +1,71 @@
+# Using as a Play client
+
+Add the dependency:
+
+```scala
+"com.softwaremill.sttp.tapir" %% "tapir-play-client" % "0.17.0-M6"
+```
+
+To make requests using an endpoint definition using the [play client](https://github.com/playframework/play-ws), import:
+
+```scala
+import sttp.tapir.client.play._
+```
+
+This adds the two extension methods to any `Endpoint`:
+ - `toPlayRequestUnsafe(String)`: given the base URI returns a function,
+   which will generate a request and a response parser which might throw
+   an exception when decoding of the result fails
+   ```scala
+   I => (StandaloneWSRequest, StandaloneWSResponse => Either[E, O])
+   ```
+ - `toPlayRequest(String)`: given the base URI returns a function,
+   which will generate a request and a response parser which represents
+   decoding errors as the `DecodeResult` class
+   ```scala
+   I => (StandaloneWSRequest, StandaloneWSResponse => DecodeResult[Either[E, O]])
+   ```
+
+Note that these are a one-argument functions, where the single argument is the input of end endpoint. This might be a 
+single type, a tuple, or a case class, depending on the endpoint description. 
+
+After providing the input parameters, the two following are returned:
+- a description of the request to be made, with the input value
+  encoded as appropriate request parameters: path, query, headers and body.
+  This can be further customised and sent using regular Play methods.
+- a response parser to be applied to the response got after executing the request.
+  The result will then contain the decoded error or success values
+  (note that this can be the body enriched with data from headers/status code).
+
+Example:
+
+```scala
+import sttp.tapir._
+import sttp.tapir.client.play._
+import sttp.capabilities.akka.AkkaStreams
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+
+import play.api.libs.ws.StandaloneWSClient
+
+def example[I, E, O, R >: AkkaStreams](implicit wsClient: StandaloneWSClient) {
+  val e: Endpoint[I, E, O, R] = ???
+  val inputArgs: I = ???
+  
+  val (req, responseParser) = e
+      .toPlayRequestUnsafe(s"http://localhost:9000")
+      .apply(inputArgs)
+  
+  val result: Future[Either[E, O]] = req
+      .execute()
+      .map(responseParser)
+}
+```
+
+## Limitations
+
+Multipart requests are not supported.
+
+Streaming capabilities:
+- only `AkkaStreams` is supported

generated-doc/out/client/sttp.md

@@ -0,0 +1,51 @@
+# Using as an sttp client
+
+Add the dependency:
+
+```scala
+"com.softwaremill.sttp.tapir" %% "tapir-sttp-client" % "0.17.0-M6"
+```
+
+To make requests using an endpoint definition using the [sttp client](https://github.com/softwaremill/sttp), import:
+
+```scala
+import sttp.tapir.client.sttp._
+```
+
+This adds the two extension methods to any `Endpoint`:
+ - `toSttpRequestUnsafe(Uri)`: given the base URI returns a function, which might throw an exception if 
+   decoding of the result fails
+   ```scala
+   I => Request[Either[E, O], Any]
+   ```
+ - `toSttpRequest(Uri)`: given the base URI returns a function, which represents decoding errors as the `DecodeResult` 
+   class
+   ```scala
+   I => Request[DecodeResult[Either[E, O]], Any]
+   ```
+
+Note that these are a one-argument functions, where the single argument is the input of end endpoint. This might be a 
+single type, a tuple, or a case class, depending on the endpoint description. 
+
+After providing the input parameters, a description of the request to be made is returned, with the input value
+encoded as appropriate request parameters: path, query, headers and body. This can be further 
+customised and sent using any sttp backend. The response will then contain the decoded error or success values
+(note that this can be the body enriched with data from headers/status code).
+
+See  the [runnable example](https://github.com/softwaremill/tapir/blob/master/examples/src/main/scala/sttp/tapir/examples/BooksExample.scala)
+for example usage.
+
+## Web sockets
+
+To interpret a web socket enddpoint, an additional streams-specific import is needed, so that the interpreter can
+convert sttp's `WebSocket` instance into a pipe. This logic is looked up via the `WebSocketToPipe` implicit.
+
+The required imports are as follows:
+
+```scala
+import sttp.tapir.client.sttp.ws.akkahttp._ // for akka-streams // for akka-streams
+import sttp.tapir.client.sttp.ws.fs2._      // for fs2
+```
+
+No additional dependencies are needed, as both of the above implementations are included in the main interpreter,]
+with dependencies on akka-streams and fs2 being marked as optional (hence these are not transitive).