quick

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val DefaultReadTimeout: Duration

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.

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.

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

def asByteArrayAlways: ResponseAs[Array[Byte], Any]

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.

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

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

final def asInstanceOf[T0]: T0

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

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

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

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

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

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

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

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

def asPath(path: Path): ResponseAs[Either[String, Path], Any]

def asPathAlways(path: Path): ResponseAs[Path, Any]

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

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

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

def asStreamAlwaysWithMetadata[F[_], T, S](s: Streams[S])(f: (BinaryStream, ResponseMetadata) ⇒ F[T]): ResponseAs[T, Effect[F] with S]

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

def asStreamWithMetadata[F[_], T, S](s: Streams[S])(f: (BinaryStream, ResponseMetadata) ⇒ F[T]): ResponseAs[Either[String, T], Effect[F] with S]

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

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

def asString: ResponseAs[Either[String, String], Any]

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

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

def asStringAlways: ResponseAs[String, Any]

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

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

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

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

def asWebSocketAlwaysWithMetadata[F[_], T](f: (WebSocket[F], ResponseMetadata) ⇒ F[T]): ResponseAs[T, Effect[F] with WebSockets]

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.

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

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

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

def asWebSocketWithMetadata[F[_], T](f: (WebSocket[F], ResponseMetadata) ⇒ F[T]): ResponseAs[Either[String, T], Effect[F] with WebSockets]

lazy val backend: SttpBackend[Identity, Any]

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

def clone(): AnyRef

val emptyRequest: RequestT[Empty, Either[String, String], Any]

An empty request with no headers.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

final def getClass(): Class[_]

def hashCode(): Int

def ignore: ResponseAs[Unit, Any]

final def isInstanceOf[T0]: Boolean

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.

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

Encodes the given parameters as form data.

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

Encodes the given parameters as form data using utf-8.

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

Encodes the given parameters as form data.

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

Encodes the given parameters as form data using utf-8.

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.

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.

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.

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

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

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.

def multipartFile(name: String, data: Path): Part[RequestBody[Any]]

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

def multipartFile(name: String, data: File): Part[RequestBody[Any]]

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

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.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val quickRequest: RequestT[Empty, String, Any]

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

lazy val simpleHttpClient: SimpleHttpClient

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

def toString(): String

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit