RequestT

Instance Constructors

new RequestT(method: U[Method], uri: U[Uri], body: RequestBody[R], headers: Seq[Header], response: ResponseAs[T, R], options: RequestOptions, tags: Map[String, Any])

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.

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def acceptEncoding(encoding: String): RequestT[U, T, R]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def auth: SpecifyAuthScheme[U, T, R]
def body(fs: Seq[(String, String)], encoding: String): RequestT[U, T, R]

Encodes the given parameters as form data.
Encodes the given parameters as form data. If content type is not yet specified, will be set to application/x-www-form-urlencoded.
If content length is not yet specified, will be set to the length of the number of bytes in the url-encoded parameter string.
def body(fs: (String, String)*): RequestT[U, T, R]

Encodes the given parameters as form data using utf-8.
Encodes the given parameters as form data using utf-8. If content type is not yet specified, will be set to application/x-www-form-urlencoded.
If content length is not yet specified, will be set to the length of the number of bytes in the url-encoded parameter string.
def body(fs: Map[String, String], encoding: String): RequestT[U, T, R]

Encodes the given parameters as form data.
Encodes the given parameters as form data. If content type is not yet specified, will be set to application/x-www-form-urlencoded.
If content length is not yet specified, will be set to the length of the number of bytes in the url-encoded parameter string.
def body(fs: Map[String, String]): RequestT[U, T, R]

Encodes the given parameters as form data using utf-8.
Encodes the given parameters as form data using utf-8. If content type is not yet specified, will be set to application/x-www-form-urlencoded.
If content length is not yet specified, will be set to the length of the number of bytes in the url-encoded parameter string.
def body(b: InputStream): RequestT[U, T, R]

If content type is not yet specified, will be set to application/octet-stream.
def body(b: ByteBuffer): RequestT[U, T, R]

If content type is not yet specified, will be set to application/octet-stream.
def body(b: Array[Byte]): RequestT[U, T, R]

If content type is not yet specified, will be set to application/octet-stream.
If content type is not yet specified, will be set to application/octet-stream.
If content length is not yet specified, will be set to the length of the given array.
def body(b: String, encoding: String): RequestT[U, T, R]

If content type is not yet specified, will be set to text/plain with the given encoding.
If content type is not yet specified, will be set to text/plain with the given encoding.
If content length is not yet specified, will be set to the number of bytes in the string using the given encoding.
def body(b: String): RequestT[U, T, R]

Uses the utf-8 encoding.
Uses the utf-8 encoding.
If content type is not yet specified, will be set to text/plain with utf-8 encoding.
If content length is not yet specified, will be set to the number of bytes in the string using the utf-8 encoding.
def body[B](b: B)(implicit arg0: BodySerializer[B]): RequestT[U, T, R]

If content type is not yet specified, will be set to application/octet-stream.
If content type is not yet specified, will be set to application/octet-stream.

Definition Classes
RequestTExtensions
def body(path: Path): RequestT[U, T, R]

If content type is not yet specified, will be set to application/octet-stream.
If content type is not yet specified, will be set to application/octet-stream.
If content length is not yet specified, will be set to the length of the given file.

Definition Classes
RequestTExtensions
def body(file: File): RequestT[U, T, R]

If content type is not yet specified, will be set to application/octet-stream.
If content type is not yet specified, will be set to application/octet-stream.
If content length is not yet specified, will be set to the length of the given file.

Definition Classes
RequestTExtensions
val body: RequestBody[R]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def contentLength(l: Long): RequestT[U, T, R]
def contentLength: Option[Long]

Definition Classes
HasHeaders
def contentType(ct: String, encoding: String): RequestT[U, T, R]
def contentType(mt: MediaType): RequestT[U, T, R]
def contentType(ct: String): RequestT[U, T, R]
def contentType: Option[String]

Definition Classes
HasHeaders
def cookie(n: String, v: String): RequestT[U, T, R]
def cookie(nv: (String, String)): RequestT[U, T, R]
def cookies(nvs: (String, String)*): RequestT[U, T, R]
def cookies(cs: Iterable[CookieWithMeta]): RequestT[U, T, R]
def cookies(r: Response[_]): RequestT[U, T, R]
def cookies: Seq[CookieWithMeta]

Definition Classes
HasHeaders
def delete(uri: Uri): Request[T, R]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def followRedirects(fr: Boolean): RequestT[U, T, R]
def get(uri: Uri): Request[T, R]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def head(uri: Uri): Request[T, R]
def header(k: String, ov: Option[String]): RequestT[U, T, R]
def header(k: String, v: String): RequestT[U, T, R]
def header(k: String, v: String, replaceExisting: Boolean): RequestT[U, T, R]

Adds the given header to the end of the headers sequence.
Adds the given header to the end of the headers sequence.
replaceExisting
If there's already a header with the same name, should it be dropped?
def header(h: Header, replaceExisting: Boolean = false): RequestT[U, T, R]

Adds the given header to the end of the headers sequence.
Adds the given header to the end of the headers sequence.
replaceExisting
If there's already a header with the same name, should it be dropped?
def header(h: String): Option[String]

Definition Classes
HasHeaders
def headers(hs: Header*): RequestT[U, T, R]
def headers(hs: Map[String, String]): RequestT[U, T, R]
def headers(h: String): Seq[String]

Definition Classes
HasHeaders
val headers: Seq[Header]

Definition Classes
RequestT → HasHeaders
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isWebSocket: Boolean
def mapResponse[T2](f: (T) ⇒ T2): RequestT[U, T2, R]
def maxRedirects(n: Int): RequestT[U, T, R]
def method(method: Method, uri: Uri): Request[T, R]
val method: U[Method]
def multipartBody[R2](p1: Part[RequestBody[R2]], ps: Part[RequestBody[R2]]*): RequestT[U, T, R with R2]
def multipartBody[R2](ps: Seq[Part[RequestBody[R2]]]): RequestT[U, T, R with R2]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def options(uri: Uri): Request[T, R]
val options: RequestOptions
def patch(uri: Uri): Request[T, R]
def post(uri: Uri): Request[T, R]
def proxyAuth: SpecifyAuthScheme[U, T, R]
def put(uri: Uri): Request[T, R]
def readTimeout(t: Duration): RequestT[U, T, R]
def redirectToGet(r: Boolean): RequestT[U, T, R]

When a POST or PUT request is redirected, should the redirect be a POST/PUT as well (with the original body), or should the request be converted to a GET without a body.
When a POST or PUT request is redirected, should the redirect be a POST/PUT as well (with the original body), or should the request be converted to a GET without a body.
Note that this only affects 301 and 302 redirects. 303 redirects are always converted, while 307 and 308 redirects always keep the same method.
See https://developer.mozilla.org/en-US/docs/Web/HTTP/Redirections for details.
def response[T2, R2](ra: ResponseAs[T2, R2]): RequestT[U, T2, R with R2]

Specifies the target type to which the response body should be read.
Specifies the target type to which the response body should be read. Note that this replaces any previous specifications, which also includes any previous mapResponse invocations.
val response: ResponseAs[T, R]

Description of how the response body should be handled.
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.
def send[F[_], P](backend: SttpBackend[F, P])(implicit isIdInRequest: IsIdInRequest[U], pEffectFIsR: <:<[P with Effect[F], R]): F[Response[T]]

Sends the request, using the given backend.
Sends the request, using the given backend. Only requests for which the method & URI are specified can be sent.
The required capabilities must be a subset of the capabilities provided by the backend.
returns
For synchronous backends (when the effect type is Identity), Response is returned directly and exceptions are thrown. For asynchronous backends (when the effect type is e.g. scala.concurrent.Future), an effect containing the Response is returned. Exceptions are represented as failed effects (e.g. failed futures). The response body is deserialized as specified by this request (see RequestT.response). Known exceptions are converted by backends to one of SttpClientException. Other exceptions are thrown unchanged.
def show(includeBody: Boolean = true, sensitiveHeaders: Set[String] = HeaderNames.SensitiveHeaders): String
def showBasic: String
def streamBody[S](s: Streams[S])(b: BinaryStream): RequestT[U, T, R with S]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tag(k: String): Option[Any]
def tag(k: String, v: Any): RequestT[U, T, R]
val tags: Map[String, Any]

Request-specific tags which can be used by backends for logging, metrics, etc.
Request-specific tags which can be used by backends for logging, metrics, etc. Not used by default.
def toCurl(implicit isIdInRequest: IsIdInRequest[U]): String
val uri: U[Uri]
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.
def send[F[_], P]()(implicit backend: SttpBackend[F, P], pEffectFIsR: <:<[P with Effect[F], R], isIdInRequest: IsIdInRequest[U]): F[Response[T]]

Sends the request, using the backend from the implicit scope.
Sends the request, using the backend from the implicit scope. Only requests for which the method & URI are specified can be sent.
The required capabilities must be a subset of the capabilities provided by the backend.
returns
For synchronous backends (when the effect type is Identity), Response is returned directly and exceptions are thrown. For asynchronous backends (when the effect type is e.g. scala.concurrent.Future), an effect containing the Response is returned. Exceptions are represented as failed effects (e.g. failed futures). The response body is deserialized as specified by this request (see RequestT.response). Known exceptions are converted by backends to one of SttpClientException. Other exceptions are thrown unchanged.

Annotations
@deprecated
Deprecated
(Since version 3.0.0) use request.send(backend), providing the backend explicitly

Related Docs: object RequestT | package client3

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

Instance Constructors

new RequestT(method: U[Method], uri: U[Uri], body: RequestBody[R], headers: Seq[Header], response: ResponseAs[T, R], options: RequestOptions, tags: Map[String, Any])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def acceptEncoding(encoding: String): RequestT[U, T, R]

final def asInstanceOf[T0]: T0

def auth: SpecifyAuthScheme[U, T, R]

def body(fs: Seq[(String, String)], encoding: String): RequestT[U, T, R]

def body(fs: (String, String)*): RequestT[U, T, R]

def body(fs: Map[String, String], encoding: String): RequestT[U, T, R]

def body(fs: Map[String, String]): RequestT[U, T, R]

def body(b: InputStream): RequestT[U, T, R]

def body(b: ByteBuffer): RequestT[U, T, R]

def body(b: Array[Byte]): RequestT[U, T, R]

def body(b: String, encoding: String): RequestT[U, T, R]

def body(b: String): RequestT[U, T, R]

def body[B](b: B)(implicit arg0: BodySerializer[B]): RequestT[U, T, R]

def body(path: Path): RequestT[U, T, R]

def body(file: File): RequestT[U, T, R]

val body: RequestBody[R]

def clone(): AnyRef

def contentLength(l: Long): RequestT[U, T, R]

def contentLength: Option[Long]

def contentType(ct: String, encoding: String): RequestT[U, T, R]

def contentType(mt: MediaType): RequestT[U, T, R]

def contentType(ct: String): RequestT[U, T, R]

def contentType: Option[String]

def cookie(n: String, v: String): RequestT[U, T, R]

def cookie(nv: (String, String)): RequestT[U, T, R]

def cookies(nvs: (String, String)*): RequestT[U, T, R]

def cookies(cs: Iterable[CookieWithMeta]): RequestT[U, T, R]

def cookies(r: Response[_]): RequestT[U, T, R]

def cookies: Seq[CookieWithMeta]

def delete(uri: Uri): Request[T, R]

final def eq(arg0: AnyRef): Boolean

def followRedirects(fr: Boolean): RequestT[U, T, R]

def get(uri: Uri): Request[T, R]

final def getClass(): Class[_]

def head(uri: Uri): Request[T, R]

def header(k: String, ov: Option[String]): RequestT[U, T, R]

def header(k: String, v: String): RequestT[U, T, R]

def header(k: String, v: String, replaceExisting: Boolean): RequestT[U, T, R]

def header(h: Header, replaceExisting: Boolean = false): RequestT[U, T, R]

def header(h: String): Option[String]

def headers(hs: Header*): RequestT[U, T, R]

def headers(hs: Map[String, String]): RequestT[U, T, R]

def headers(h: String): Seq[String]

val headers: Seq[Header]

final def isInstanceOf[T0]: Boolean

def isWebSocket: Boolean

def mapResponse[T2](f: (T) ⇒ T2): RequestT[U, T2, R]

def maxRedirects(n: Int): RequestT[U, T, R]

def method(method: Method, uri: Uri): Request[T, R]

val method: U[Method]

def multipartBody[R2](p1: Part[RequestBody[R2]], ps: Part[RequestBody[R2]]*): RequestT[U, T, R with R2]

def multipartBody[R2](ps: Seq[Part[RequestBody[R2]]]): RequestT[U, T, R with R2]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def options(uri: Uri): Request[T, R]

val options: RequestOptions

def patch(uri: Uri): Request[T, R]

def post(uri: Uri): Request[T, R]

def proxyAuth: SpecifyAuthScheme[U, T, R]

def put(uri: Uri): Request[T, R]

def readTimeout(t: Duration): RequestT[U, T, R]

def redirectToGet(r: Boolean): RequestT[U, T, R]

def response[T2, R2](ra: ResponseAs[T2, R2]): RequestT[U, T2, R with R2]

val response: ResponseAs[T, R]

def send[F[_], P](backend: SttpBackend[F, P])(implicit isIdInRequest: IsIdInRequest[U], pEffectFIsR: <:<[P with Effect[F], R]): F[Response[T]]

def show(includeBody: Boolean = true, sensitiveHeaders: Set[String] = HeaderNames.SensitiveHeaders): String

def showBasic: String

def streamBody[S](s: Streams[S])(b: BinaryStream): RequestT[U, T, R with S]

final def synchronized[T0](arg0: ⇒ T0): T0

def tag(k: String): Option[Any]