client

Type Members

abstract class AbstractFetchBackend[F[_], S <: Streams[S], P] extends SttpBackend[F, P]

A backend that uses the fetch JavaScript api.
A backend that uses the fetch JavaScript api.

See also
https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
sealed trait BasicRequestBody extends RequestBody[Any]
type BodySerializer[B] = (B) ⇒ BasicRequestBody

Provide an implicit value of this type to serialize arbitrary classes into a request body.
Provide an implicit value of this type to serialize arbitrary classes into a request body. Backends might also provide special logic for serializer instances which they define (e.g. to handle streaming).
case class ByteArrayBody(b: Array[Byte], defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable
case class ByteBufferBody(b: ByteBuffer, defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable
case class ConditionalResponseAs[+T, R](condition: (ResponseMetadata) ⇒ Boolean, responseAs: ResponseAs[T, R]) extends Product with Serializable
case class DeserializationException[DE](body: String, error: DE)(implicit evidence$5: ShowError[DE]) extends ResponseException[Nothing, DE] with Product with Serializable
class DigestAuthenticationBackend[F[_], P] extends SttpBackend[F, P]
class EitherBackend[P] extends SttpBackend[[β$0$]Either[Throwable, β$0$], P]

A synchronous backend that safely wraps SttpBackend exceptions in Either[Throwable, *]'s
A synchronous backend that safely wraps SttpBackend exceptions in Either[Throwable, *]'s
P
TODO
type Empty[X] = None.type
class FetchBackend extends AbstractFetchBackend[Future, Nothing, Any]
final case class FetchOptions(credentials: Option[RequestCredentials], mode: Option[RequestMode]) extends Product with Serializable
case class FileBody(f: SttpFile, defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable
class FollowRedirectsBackend[F[_], P] extends SttpBackend[F, P]
case class HttpError[HE](body: HE, statusCode: StatusCode) extends ResponseException[HE, Nothing] with Product with Serializable
type Identity[X] = X
case class InputStreamBody(b: InputStream, defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable
case class MappedResponseAs[T, T2, R](raw: ResponseAs[T, R], g: (T, ResponseMetadata) ⇒ T2, showAs: Option[String]) extends ResponseAs[T2, R] with Product with Serializable
case class MultipartBody[R](parts: Seq[Part[RequestBody[R]]]) extends RequestBody[R] with Product with Serializable
type PartialRequest[T, -R] = RequestT[Empty, T, R]

A RequestT without the method & uri specified (which cannot yet be sent).
type Request[T, -R] = RequestT[Identity, T, R]

A RequestT with the method & uri specified.
A RequestT with the method & uri specified. Such a request can be sent.
sealed trait RequestBody[-R] extends AnyRef
trait RequestMetadata extends HasHeaders
case class RequestOptions(followRedirects: Boolean, readTimeout: Duration, maxRedirects: Int, redirectToGet: Boolean) extends Product with Serializable
case class RequestT[U[_], T, -R](method: U[Method], uri: U[Uri], body: RequestBody[R], headers: Seq[Header], response: ResponseAs[T, R], options: RequestOptions, tags: Map[String, Any]) extends HasHeaders with RequestTExtensions[U, T, R] with Product with Serializable

Describes a HTTP request, along with a description of how the response body should be handled.
Describes a HTTP request, along with a description of how the response body should be handled.
The request can be sent using a SttpBackend, which provides a superset of the required capabilities.
U
Specifies if the method & uri are specified. By default can be either: * Empty, which is a type constructor which always resolves to None. This type of request is aliased to PartialRequest: there's no method and uri specified, and the request cannot be sent. * Identity, which is an identity type constructor. This type of request is aliased to Request: the method and uri are specified, and the request can be sent.
T
The target type, to which the response body should be read.
R
The backend capabilities required by the request or response description. This might be Any (no requirements), Effect (the backend must support the given effect type), Streams (the ability to send and receive streaming bodies) or sttp.capabilities.WebSockets (the ability to handle websocket requests).
response
Description of how the response body should be handled. Needs to be specified upfront so that the response is always consumed and hence there are no requirements on client code to consume it. An exception to this are unsafe streaming and websocket responses, which need to be consumed/closed by the client.
tags
Request-specific tags which can be used by backends for logging, metrics, etc. Not used by default.
trait RequestTExtensions[U[_], T, -R] extends AnyRef
case class Response[T](body: T, code: StatusCode, statusText: String, headers: Seq[Header], history: List[Response[Unit]], request: RequestMetadata) extends ResponseMetadata with Product with Serializable

history
If redirects are followed, and there were redirects, contains responses for the intermediate requests. The first response (oldest) comes first.
sealed trait ResponseAs[+T, -R] extends AnyRef

Describes how response body should be handled.
Describes how response body should be handled.
Apart from the basic cases (ignoring, reading as a byte array or file), response body descriptions can be mapped over, to support custom types. The mapping can take into account the ResponseMetadata, that is the headers and status code. Responses can also be handled depending on the response metadata. Finally, two response body descriptions can be combined (with some restrictions).
A number of as[Type] helper methods are available as part of SttpApi and when importing sttp.client._.
T
Target type as which the response will be read.
R
The backend capabilities required by the response description. This might be Any (no requirements), Effect (the backend must support the given effect type), Streams (the ability to send and receive streaming bodies) or WebSockets (the ability to handle websocket requests).
case class ResponseAsBoth[A, B, R](l: ResponseAs[A, R], r: ResponseAs[B, Any]) extends ResponseAs[(A, Option[B]), R] with Product with Serializable
case class ResponseAsFile(output: SttpFile) extends ResponseAs[SttpFile, Any] with Product with Serializable
case class ResponseAsFromMetadata[T, R](conditions: List[ConditionalResponseAs[T, R]], default: ResponseAs[T, R]) extends ResponseAs[T, R] with Product with Serializable
case class ResponseAsStream[F[_], T, Stream, S] extends ResponseAs[T, Effect[F] with S] with Product with Serializable
case class ResponseAsStreamUnsafe[BinaryStream, S] extends ResponseAs[BinaryStream, S] with Product with Serializable
case class ResponseAsWebSocket[F[_], T](f: (WebSocket[F]) ⇒ F[T]) extends WebSocketResponseAs[T, Effect[F] with WebSockets] with Product with Serializable
case class ResponseAsWebSocketStream[S, Pipe[_, _]](s: Streams[S], p: Pipe[Data[_], WebSocketFrame]) extends WebSocketResponseAs[Unit, S with WebSockets] with Product with Serializable
case class ResponseAsWebSocketUnsafe[F[_]]() extends WebSocketResponseAs[WebSocket[F], Effect[F] with WebSockets] with Product with Serializable
sealed abstract class ResponseException[+HE, +DE] extends Exception
trait ResponseMetadata extends HasHeaders
type RetryWhen = (Request[_, _], Either[Throwable, Response[_]]) ⇒ Boolean
trait ShowError[-T] extends AnyRef
class SpecifyAuthScheme[U[_], T, -R] extends AnyRef
case class StreamBody[BinaryStream, S] extends RequestBody[S] with Product with Serializable
case class StringBody(s: String, encoding: String, defaultContentType: MediaType = MediaType.TextPlain) extends BasicRequestBody with Product with Serializable
trait SttpApi extends SttpExtensions with UriInterpolator
trait SttpBackend[F[_], +P] extends AnyRef

A backend is used to send HTTP requests described by RequestT.
A backend is used to send HTTP requests described by RequestT. Backends might wrap Java or Scala HTTP clients, or other backends.
F
The effect type used when returning responses. E.g. Identity for synchronous backends, scala.concurrent.Future for asynchronous backends.
P
Capabilities supported by this backend, in addition to Effect. This might be Any (no special capabilities), Streams (the ability to send and receive streaming bodies) or WebSockets (the ability to handle websocket requests).

Note
Backends should try to classify exceptions into one of the categories specified by SttpClientException. Other exceptions should be thrown unchanged.
case class SttpBackendOptions(connectionTimeout: FiniteDuration, proxy: Option[Proxy]) extends Product with Serializable
abstract class SttpClientException extends Exception

Known exceptions that might occur when using a backend.
Known exceptions that might occur when using a backend. Currently this covers: - connect exceptions: when a connection (tcp socket) can't be established to the target host - read exceptions: when a connection has been established, but there's any kind of problem receiving or handling the response (e.g. a broken socket or a deserialization error)
In general, it's safe to assume that the request hasn't been sent in case of connect exceptions. With read exceptions, the target host might or might have not received and processed the request.
The SttpBackend.send methods might also throw other exceptions, due to programming errors, bugs in the underlying implementations, bugs in sttp or an uncovered exception.
trait SttpExtensions extends AnyRef
trait ToCurlConverterTestExtension extends AnyRef
case class TooManyRedirectsException(uri: Uri, redirects: Int) extends Exception with Product with Serializable
class TryBackend[P] extends SttpBackend[Try, P]

A synchronous backend that safely wraps SttpBackend exceptions in Try's
A synchronous backend that safely wraps SttpBackend exceptions in Try's
P
TODO
implicit class UriContext extends AnyRef

Definition Classes
UriInterpolator
sealed trait WebSocketResponseAs[T, -R] extends ResponseAs[T, R]
type DeserializationError[DE] = DeserializationException[DE]

Annotations
@deprecated
Deprecated
(Since version 3.0.0) use DeserializationException
type ResponseError[+HE, +DE] = ResponseException[HE, DE]

Annotations
@deprecated
Deprecated
(Since version 3.0.0) use ResponseException

Value Members

val DefaultReadTimeout: Duration

Definition Classes
SttpApi
object DigestAuthenticationBackend
object FetchBackend
object FetchOptions extends Serializable
object FollowRedirectsBackend
object IgnoreResponse extends ResponseAs[Unit, Any] with Product with Serializable
object NoBody extends RequestBody[Any] with Product with Serializable
object RequestBody
object RequestMetadata
object RequestT extends Serializable
object Response extends Serializable
object ResponseAs
object ResponseAsByteArray extends ResponseAs[Array[Byte], Any] with Product with Serializable
object ResponseAsStream extends Serializable
object ResponseAsStreamUnsafe extends Serializable
object ResponseMetadata
object RetryWhen
object ShowError
object StreamBody extends Serializable
object SttpBackendOptions extends Serializable
object SttpClientException extends Serializable
def asBoth[A, B](l: ResponseAs[A, Any], r: ResponseAs[B, Any]): ResponseAs[(A, B), Any]

Use both l and r to read the response body.
Use both l and r to read the response body. Neither response specifications may use streaming or web sockets.

Definition Classes
SttpApi
def asBothOption[A, B, R](l: ResponseAs[A, R], r: ResponseAs[B, Any]): ResponseAs[(A, Option[B]), R]

Use l to read the response body.
Use l to read the response body. If the raw body value which is used by l is replayable (a file or byte array), also use r to read the response body. Otherwise ignore r (if the raw body is a stream or a web socket).

Definition Classes
SttpApi
def asByteArray: ResponseAs[Either[String, Array[Byte]], Any]

Definition Classes
SttpApi
def asByteArrayAlways: ResponseAs[Array[Byte], Any]

Definition Classes
SttpApi
def asEither[A, B, R](onError: ResponseAs[A, R], onSuccess: ResponseAs[B, R]): ResponseAs[Either[A, B], R]

Uses the onSuccess response specification for successful responses (2xx), and the onError specification otherwise.
Uses the onSuccess response specification for successful responses (2xx), and the onError specification otherwise.

Definition Classes
SttpApi
def asFile(file: File): ResponseAs[Either[String, File], Any]

Definition Classes
SttpExtensions
def asFileAlways(file: File): ResponseAs[File, Any]

Definition Classes
SttpExtensions
def asParams(charset: String): ResponseAs[Either[String, Seq[(String, String)]], Any]

Use the given charset by default, unless specified otherwise in the response headers.
Use the given charset by default, unless specified otherwise in the response headers.

Definition Classes
SttpApi
def asParams: ResponseAs[Either[String, Seq[(String, String)]], Any]

Use the utf-8 charset by default, unless specified otherwise in the response headers.
Use the utf-8 charset by default, unless specified otherwise in the response headers.

Definition Classes
SttpApi
def asParamsAlways(charset: String): ResponseAs[Seq[(String, String)], Any]

Use the given charset by default, unless specified otherwise in the response headers.
Use the given charset by default, unless specified otherwise in the response headers.

Definition Classes
SttpApi
def asParamsAlways: ResponseAs[Seq[(String, String)], Any]

Use the utf-8 charset by default, unless specified otherwise in the response headers.
Use the utf-8 charset by default, unless specified otherwise in the response headers.

Definition Classes
SttpApi
def asStream[F[_], T, S](s: Streams[S])(f: (BinaryStream) ⇒ F[T]): ResponseAs[Either[String, T], Effect[F] with S]

Definition Classes
SttpApi
def asStreamAlways[F[_], T, S](s: Streams[S])(f: (BinaryStream) ⇒ F[T]): ResponseAs[T, Effect[F] with S]

Definition Classes
SttpApi
def asStreamAlwaysUnsafe[S](s: Streams[S]): ResponseAs[BinaryStream, S]

Definition Classes
SttpApi
def asStreamUnsafe[S](s: Streams[S]): ResponseAs[Either[String, BinaryStream], S]

Definition Classes
SttpApi
def asString(charset: String): ResponseAs[Either[String, String], Any]

Use the given charset by default, unless specified otherwise in the response headers.
Use the given charset by default, unless specified otherwise in the response headers.

Definition Classes
SttpApi
def asString: ResponseAs[Either[String, String], Any]

Use the utf-8 charset by default, unless specified otherwise in the response headers.
Use the utf-8 charset by default, unless specified otherwise in the response headers.

Definition Classes
SttpApi
def asStringAlways(charset: String): ResponseAs[String, Any]

Definition Classes
SttpApi
def asStringAlways: ResponseAs[String, Any]

Use the utf-8 charset by default, unless specified otherwise in the response headers.
Use the utf-8 charset by default, unless specified otherwise in the response headers.

Definition Classes
SttpApi
def asWebSocket[F[_], T](f: (WebSocket[F]) ⇒ F[T]): ResponseAs[Either[String, T], Effect[F] with WebSockets]

Definition Classes
SttpApi
def asWebSocketAlways[F[_], T](f: (WebSocket[F]) ⇒ F[T]): ResponseAs[T, Effect[F] with WebSockets]

Definition Classes
SttpApi
def asWebSocketAlwaysUnsafe[F[_]]: ResponseAs[WebSocket[F], Effect[F] with WebSockets]

Definition Classes
SttpApi
def asWebSocketEither[A, B, R](onError: ResponseAs[A, R], onSuccess: ResponseAs[B, R]): ResponseAs[Either[A, B], R]

Uses the onSuccess response specification for 101 responses (switching protocols), and the onError specification otherwise.
Uses the onSuccess response specification for 101 responses (switching protocols), and the onError specification otherwise.

Definition Classes
SttpApi
def asWebSocketStream[S](s: Streams[S])(p: Pipe[Data[_], WebSocketFrame]): ResponseAs[Either[String, Unit], S with WebSockets]

Definition Classes
SttpApi
def asWebSocketStreamAlways[S](s: Streams[S])(p: Pipe[Data[_], WebSocketFrame]): ResponseAs[Unit, S with WebSockets]

Definition Classes
SttpApi
def asWebSocketUnsafe[F[_]]: ResponseAs[Either[String, WebSocket[F]], Effect[F] with WebSockets]

Definition Classes
SttpApi
val basicRequest: RequestT[Empty, Either[String, String], Any]

A starting request, with the following modification comparing to emptyRequest: Accept-Encoding is set to gzip, deflate (compression/decompression is handled automatically by the library).
A starting request, with the following modification comparing to emptyRequest: Accept-Encoding is set to gzip, deflate (compression/decompression is handled automatically by the library).
Reads the response body as an Either[String, String], where Left is used if the status code is non-2xx, and Right otherwise.

Definition Classes
SttpApi
package dom
val emptyRequest: RequestT[Empty, Either[String, String], Any]

An empty request with no headers.
An empty request with no headers.
Reads the response body as an Either[String, String], where Left is used if the status code is non-2xx, and Right otherwise.

Definition Classes
SttpApi
def fromMetadata[T, R](default: ResponseAs[T, R], conditions: ConditionalResponseAs[T, R]*): ResponseAs[T, R]

Definition Classes
SttpApi
def ignore: ResponseAs[Unit, Any]

Definition Classes
SttpApi
package internal
package listener
package logging
package monad
def multipart[B](name: String, b: B)(implicit arg0: BodySerializer[B]): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.
Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipart(name: String, fs: Seq[(String, String)], encoding: String): Part[BasicRequestBody]

Encodes the given parameters as form data.
Encodes the given parameters as form data.
Content type will be set to application/x-www-form-urlencoded, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipart(name: String, fs: Seq[(String, String)]): Part[BasicRequestBody]

Encodes the given parameters as form data using utf-8.
Encodes the given parameters as form data using utf-8.
Content type will be set to application/x-www-form-urlencoded, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipart(name: String, fs: Map[String, String], encoding: String): Part[BasicRequestBody]

Encodes the given parameters as form data.
Encodes the given parameters as form data.
Content type will be set to application/x-www-form-urlencoded, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipart(name: String, fs: Map[String, String]): Part[BasicRequestBody]

Encodes the given parameters as form data using utf-8.
Encodes the given parameters as form data using utf-8.
Content type will be set to application/x-www-form-urlencoded, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipart(name: String, data: InputStream): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.
Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipart(name: String, data: ByteBuffer): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.
Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipart(name: String, data: Array[Byte]): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.
Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipart(name: String, data: String, encoding: String): Part[BasicRequestBody]

Content type will be set to text/plain with utf-8 encoding, can be overridden later using the contentType method.
Content type will be set to text/plain with utf-8 encoding, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipart(name: String, data: String): Part[BasicRequestBody]

Content type will be set to text/plain with utf-8 encoding, can be overridden later using the contentType method.
Content type will be set to text/plain with utf-8 encoding, can be overridden later using the contentType method.

Definition Classes
SttpApi
def multipartFile(name: String, file: File): Part[BasicRequestBody]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.
Content type will be set to application/octet-stream, can be overridden later using the contentType method.
File name will be set to the name of the file.

Definition Classes
SttpExtensions
def multipartStream[S](s: Streams[S])(name: String, b: BinaryStream): Part[RequestBody[S]]

Content type will be set to application/octet-stream, can be overridden later using the contentType method.
Content type will be set to application/octet-stream, can be overridden later using the contentType method.

Definition Classes
SttpApi
object quick extends SttpApi
val quickRequest: RequestT[Empty, String, Any]

A starting request which always reads the response body as a string, regardless of the status code.
A starting request which always reads the response body as a string, regardless of the status code.

Definition Classes
SttpApi
package testing
package ws

package client

Type Members

abstract class AbstractFetchBackend[F[_], S <: Streams[S], P] extends SttpBackend[F, P]

sealed trait BasicRequestBody extends RequestBody[Any]

type BodySerializer[B] = (B) ⇒ BasicRequestBody

case class ByteArrayBody(b: Array[Byte], defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable

case class ByteBufferBody(b: ByteBuffer, defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable

case class ConditionalResponseAs[+T, R](condition: (ResponseMetadata) ⇒ Boolean, responseAs: ResponseAs[T, R]) extends Product with Serializable

case class DeserializationException[DE](body: String, error: DE)(implicit evidence$5: ShowError[DE]) extends ResponseException[Nothing, DE] with Product with Serializable

class DigestAuthenticationBackend[F[_], P] extends SttpBackend[F, P]

class EitherBackend[P] extends SttpBackend[[β$0$]Either[Throwable, β$0$], P]

type Empty[X] = None.type

class FetchBackend extends AbstractFetchBackend[Future, Nothing, Any]

final case class FetchOptions(credentials: Option[RequestCredentials], mode: Option[RequestMode]) extends Product with Serializable

case class FileBody(f: SttpFile, defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable

class FollowRedirectsBackend[F[_], P] extends SttpBackend[F, P]

case class HttpError[HE](body: HE, statusCode: StatusCode) extends ResponseException[HE, Nothing] with Product with Serializable

type Identity[X] = X

case class InputStreamBody(b: InputStream, defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable

case class MappedResponseAs[T, T2, R](raw: ResponseAs[T, R], g: (T, ResponseMetadata) ⇒ T2, showAs: Option[String]) extends ResponseAs[T2, R] with Product with Serializable

case class MultipartBody[R](parts: Seq[Part[RequestBody[R]]]) extends RequestBody[R] with Product with Serializable

type PartialRequest[T, -R] = RequestT[Empty, T, R]

type Request[T, -R] = RequestT[Identity, T, R]

sealed trait RequestBody[-R] extends AnyRef

trait RequestMetadata extends HasHeaders

case class RequestOptions(followRedirects: Boolean, readTimeout: Duration, maxRedirects: Int, redirectToGet: Boolean) extends Product with Serializable

case class RequestT[U[_], T, -R](method: U[Method], uri: U[Uri], body: RequestBody[R], headers: Seq[Header], response: ResponseAs[T, R], options: RequestOptions, tags: Map[String, Any]) extends HasHeaders with RequestTExtensions[U, T, R] with Product with Serializable

trait RequestTExtensions[U[_], T, -R] extends AnyRef

case class Response[T](body: T, code: StatusCode, statusText: String, headers: Seq[Header], history: List[Response[Unit]], request: RequestMetadata) extends ResponseMetadata with Product with Serializable

sealed trait ResponseAs[+T, -R] extends AnyRef

case class ResponseAsBoth[A, B, R](l: ResponseAs[A, R], r: ResponseAs[B, Any]) extends ResponseAs[(A, Option[B]), R] with Product with Serializable

case class ResponseAsFile(output: SttpFile) extends ResponseAs[SttpFile, Any] with Product with Serializable

case class ResponseAsFromMetadata[T, R](conditions: List[ConditionalResponseAs[T, R]], default: ResponseAs[T, R]) extends ResponseAs[T, R] with Product with Serializable

case class ResponseAsStream[F[_], T, Stream, S] extends ResponseAs[T, Effect[F] with S] with Product with Serializable

case class ResponseAsStreamUnsafe[BinaryStream, S] extends ResponseAs[BinaryStream, S] with Product with Serializable

case class ResponseAsWebSocket[F[_], T](f: (WebSocket[F]) ⇒ F[T]) extends WebSocketResponseAs[T, Effect[F] with WebSockets] with Product with Serializable

case class ResponseAsWebSocketStream[S, Pipe[_, _]](s: Streams[S], p: Pipe[Data[_], WebSocketFrame]) extends WebSocketResponseAs[Unit, S with WebSockets] with Product with Serializable

case class ResponseAsWebSocketUnsafe[F[_]]() extends WebSocketResponseAs[WebSocket[F], Effect[F] with WebSockets] with Product with Serializable

sealed abstract class ResponseException[+HE, +DE] extends Exception

trait ResponseMetadata extends HasHeaders

type RetryWhen = (Request[_, _], Either[Throwable, Response[_]]) ⇒ Boolean

trait ShowError[-T] extends AnyRef

class SpecifyAuthScheme[U[_], T, -R] extends AnyRef

case class StreamBody[BinaryStream, S] extends RequestBody[S] with Product with Serializable

case class StringBody(s: String, encoding: String, defaultContentType: MediaType = MediaType.TextPlain) extends BasicRequestBody with Product with Serializable

trait SttpApi extends SttpExtensions with UriInterpolator

trait SttpBackend[F[_], +P] extends AnyRef

case class SttpBackendOptions(connectionTimeout: FiniteDuration, proxy: Option[Proxy]) extends Product with Serializable

abstract class SttpClientException extends Exception

trait SttpExtensions extends AnyRef

trait ToCurlConverterTestExtension extends AnyRef

case class TooManyRedirectsException(uri: Uri, redirects: Int) extends Exception with Product with Serializable

class TryBackend[P] extends SttpBackend[Try, P]

implicit class UriContext extends AnyRef

sealed trait WebSocketResponseAs[T, -R] extends ResponseAs[T, R]

type DeserializationError[DE] = DeserializationException[DE]

type ResponseError[+HE, +DE] = ResponseException[HE, DE]

Value Members

val DefaultReadTimeout: Duration

object DigestAuthenticationBackend

object FetchBackend

object FetchOptions extends Serializable

object FollowRedirectsBackend

object IgnoreResponse extends ResponseAs[Unit, Any] with Product with Serializable

object NoBody extends RequestBody[Any] with Product with Serializable

object RequestBody

object RequestMetadata

object RequestT extends Serializable

object Response extends Serializable

object ResponseAs

object ResponseAsByteArray extends ResponseAs[Array[Byte], Any] with Product with Serializable

object ResponseAsStream extends Serializable

object ResponseAsStreamUnsafe extends Serializable

object ResponseMetadata

object RetryWhen

object ShowError

object StreamBody extends Serializable

object SttpBackendOptions extends Serializable

object SttpClientException extends Serializable