Package

sttp

client3

Permalink

package client3

Linear Supertypes
SttpApi, UriInterpolator, SttpExtensions, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. client3
  2. SttpApi
  3. UriInterpolator
  4. SttpExtensions
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. sealed trait BasicRequestBody extends RequestBody[Any]

    Permalink
  2. type BodySerializer[B] = (B) ⇒ BasicRequestBody

    Permalink

    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).

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

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

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

    Permalink
  6. abstract class DelegateSttpBackend[F[_], +P] extends SttpBackend[F, P]

    Permalink

    A base class for delegate backends, which includes delegating implementations for close and responseMonad, so that only send needs to be defined.

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

    Permalink
  8. class DigestAuthenticationBackend[F[_], P] extends DelegateSttpBackend[F, P]

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

    Permalink

    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

  10. type Empty[X] = None.type

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

    Permalink
  12. class FollowRedirectsBackend[F[_], P] extends DelegateSttpBackend[F, P]

    Permalink

  13. abstract class HttpClientAsyncBackend[F[_], S, P, BH, B] extends HttpClientBackend[F, S, P, B]

    Permalink

    F

    The effect type

    S

    Type of supported byte streams, Nothing if none

    P

    Capabilities supported by the backend. See SttpBackend.

    BH

    The low-level type of the body, read using a HttpResponse.BodyHandler read by HttpClient.

    B

    The higher-level body to which BH is transformed (e.g. a backend-native stream representation), which then is used to read the body as described by responseAs.

  14. abstract class HttpClientBackend[F[_], S, P, B] extends SttpBackend[F, P]

    Permalink

  15. class HttpClientFutureBackend extends HttpClientAsyncBackend[Future, Nothing, WebSockets, InputStream, InputStream]

    Permalink
  16. class HttpClientSyncBackend extends HttpClientBackend[Identity, Nothing, Any, InputStream]

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

    Permalink
  18. class HttpURLConnectionBackend extends SttpBackend[Identity, Any]

    Permalink
  19. type Identity[X] = X

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

    Permalink
  21. 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

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

    Permalink
  23. type PartialRequest[T, -R] = RequestT[Empty, T, R]

    Permalink

    A RequestT without the method & uri specified (which cannot yet be sent).

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

    Permalink

    A RequestT with the method & uri specified.

    A RequestT with the method & uri specified. Such a request can be sent.

  25. sealed trait RequestBody[-R] extends AnyRef

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

    Permalink
  27. 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

    Permalink

    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:

    • synchronously, using SimpleHttpClient.send()
    • using the send(SttpBackend) methods, which support any effect. The backend must provide a superset of the capabilities required by the request.
    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.

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

    Permalink
  29. class ResolveRelativeUrisBackend[F[_], +P] extends DelegateSttpBackend[F, P]

    Permalink
  30. 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

    Permalink

    history

    If redirects are followed, and there were redirects, contains responses for the intermediate requests. The first response (oldest) comes first.

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

    Permalink

    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.client3._.

    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).

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

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

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

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

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

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

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

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

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

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

    Permalink
  42. trait ShowError[-T] extends AnyRef

    Permalink
  43. case class SimpleHttpClient(backend: SttpBackend[Identity, Any]) extends Product with Serializable

    Permalink

    A simple, synchronous http client.

    A simple, synchronous http client. Usage example:

    import sttp.client3.{SimpleHttpClient, UriContext, basicRequest}
    
    val client = SimpleHttpClient()
    val request = basicRequest.get(uri"https://httpbin.org/get")
    val response = client.send(request)
    println(response.body)

    Wraps an SttpBackend, which can be substituted or modified using wrapBackend, adding e.g. logging.

    Creating a client allocates resources, hence when no longer needed, the client should be closed using close.

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

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

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

    Permalink
  47. trait SttpApi extends SttpExtensions with UriInterpolator

    Permalink
  48. trait SttpBackend[F[_], +P] extends AnyRef

    Permalink

    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.

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

    Permalink
  50. abstract class SttpClientException extends Exception

    Permalink

    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.

  51. trait SttpClientExceptionExtensions extends AnyRef

    Permalink
  52. trait SttpExtensions extends AnyRef

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

    Permalink
  54. class TryBackend[P] extends SttpBackend[Try, P]

    Permalink

    A synchronous backend that safely wraps SttpBackend exceptions in Try's

    A synchronous backend that safely wraps SttpBackend exceptions in Try's

    P

    TODO

  55. implicit class UriContext extends AnyRef

    Permalink
    Definition Classes
    UriInterpolator
  56. sealed trait WebSocketResponseAs[T, -R] extends ResponseAs[T, R]

    Permalink
  57. type DeserializationError[DE] = DeserializationException[DE]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 3.0.0) use DeserializationException

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

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 3.0.0) use ResponseException

Value Members

  1. val DefaultReadTimeout: Duration

    Permalink
    Definition Classes
    SttpApi
  2. object DigestAuthenticationBackend

    Permalink
  3. object FollowRedirectsBackend

    Permalink
  4. object HttpClientBackend

    Permalink
  5. object HttpClientFutureBackend

    Permalink
  6. object HttpClientSyncBackend

    Permalink
  7. object HttpError extends Serializable

    Permalink
  8. object HttpURLConnectionBackend

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

    Permalink
  10. object NoBody extends RequestBody[Any] with Product with Serializable

    Permalink
  11. object RequestBody

    Permalink
  12. object RequestT extends Serializable

    Permalink
  13. object ResolveRelativeUrisBackend

    Permalink
  14. object Response extends Serializable

    Permalink
  15. object ResponseAs

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

    Permalink
  17. object ResponseAsStream extends Serializable

    Permalink
  18. object ResponseAsStreamUnsafe extends Serializable

    Permalink
  19. object RetryWhen

    Permalink
  20. object ShowError

    Permalink
  21. object SimpleHttpClient extends Serializable

    Permalink
  22. object StreamBody extends Serializable

    Permalink
  23. object SttpBackendOptions extends Serializable

    Permalink
  24. object SttpClientException extends SttpClientExceptionExtensions with Serializable

    Permalink
  25. object SttpExtensions

    Permalink
  26. object TryHttpURLConnectionBackend

    Permalink
  27. def asBoth[A, B](l: ResponseAs[A, Any], r: ResponseAs[B, Any]): ResponseAs[(A, B), Any]

    Permalink

    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
  28. def asBothOption[A, B, R](l: ResponseAs[A, R], r: ResponseAs[B, Any]): ResponseAs[(A, Option[B]), R]

    Permalink

    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
  29. def asByteArray: ResponseAs[Either[String, Array[Byte]], Any]

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

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

    Permalink

    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
  32. def asFile(file: File): ResponseAs[Either[String, File], Any]

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

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

    Permalink

    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
  35. def asParams: ResponseAs[Either[String, Seq[(String, String)]], Any]

    Permalink

    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
  36. def asParamsAlways(charset: String): ResponseAs[Seq[(String, String)], Any]

    Permalink

    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
  37. def asParamsAlways: ResponseAs[Seq[(String, String)], Any]

    Permalink

    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
  38. def asPath(path: Path): ResponseAs[Either[String, Path], Any]

    Permalink
    Definition Classes
    SttpExtensions
  39. def asPathAlways(path: Path): ResponseAs[Path, Any]

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

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

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

    Permalink
    Definition Classes
    SttpApi
  43. def asStreamAlwaysWithMetadata[F[_], T, S](s: Streams[S])(f: (BinaryStream, ResponseMetadata) ⇒ F[T]): ResponseAs[T, Effect[F] with S]

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

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

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

    Permalink

    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
  47. def asString: ResponseAs[Either[String, String], Any]

    Permalink

    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
  48. def asStringAlways(charset: String): ResponseAs[String, Any]

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

    Permalink

    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
  50. def asWebSocket[F[_], T](f: (WebSocket[F]) ⇒ F[T]): ResponseAs[Either[String, T], Effect[F] with WebSockets]

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

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

    Permalink
    Definition Classes
    SttpApi
  53. def asWebSocketAlwaysWithMetadata[F[_], T](f: (WebSocket[F], ResponseMetadata) ⇒ F[T]): ResponseAs[T, Effect[F] with WebSockets]

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

    Permalink

    Uses the onSuccess response specification for 101 responses (switching protocols) on JVM/Native, 200 responses on JS.

    Uses the onSuccess response specification for 101 responses (switching protocols) on JVM/Native, 200 responses on JS. Otherwise, use the onError specification.

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

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

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

    Permalink
    Definition Classes
    SttpApi
  58. def asWebSocketWithMetadata[F[_], T](f: (WebSocket[F], ResponseMetadata) ⇒ F[T]): ResponseAs[Either[String, T], Effect[F] with WebSockets]

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

    Permalink

    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
  60. val emptyRequest: RequestT[Empty, Either[String, String], Any]

    Permalink

    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
  61. def fromMetadata[T, R](default: ResponseAs[T, R], conditions: ConditionalResponseAs[T, R]*): ResponseAs[T, R]

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

    Permalink
    Definition Classes
    SttpApi
  63. package internal

    Permalink
  64. package listener

    Permalink
  65. package logging

    Permalink
  66. package monad

    Permalink
  67. def multipart[B](name: String, b: B)(implicit arg0: BodySerializer[B]): Part[BasicRequestBody]

    Permalink

    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
  68. def multipart(name: String, fs: Seq[(String, String)], encoding: String): Part[BasicRequestBody]

    Permalink

    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
  69. def multipart(name: String, fs: Seq[(String, String)]): Part[BasicRequestBody]

    Permalink

    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
  70. def multipart(name: String, fs: Map[String, String], encoding: String): Part[BasicRequestBody]

    Permalink

    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
  71. def multipart(name: String, fs: Map[String, String]): Part[BasicRequestBody]

    Permalink

    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
  72. def multipart(name: String, data: InputStream): Part[BasicRequestBody]

    Permalink

    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
  73. def multipart(name: String, data: ByteBuffer): Part[BasicRequestBody]

    Permalink

    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
  74. def multipart(name: String, data: Array[Byte]): Part[BasicRequestBody]

    Permalink

    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
  75. def multipart(name: String, data: String, encoding: String): Part[BasicRequestBody]

    Permalink

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

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

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

    Permalink

    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
  77. def multipartFile(name: String, data: Path): Part[RequestBody[Any]]

    Permalink

    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
  78. def multipartFile(name: String, data: File): Part[RequestBody[Any]]

    Permalink

    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
  79. def multipartStream[S](s: Streams[S])(name: String, b: BinaryStream): Part[RequestBody[S]]

    Permalink

    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
  80. object quick extends SttpApi

    Permalink
  81. val quickRequest: RequestT[Empty, String, Any]

    Permalink

    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
  82. package testing

    Permalink
  83. package ws

    Permalink

Inherited from SttpApi

Inherited from UriInterpolator

Inherited from SttpExtensions

Inherited from AnyRef

Inherited from Any

Ungrouped