HttpRequestOrResponse

abstract def body: Stream[F, Byte]

abstract def updateBody(body: Stream[F, Byte]): Self

abstract def updateHeaders(headers: List[HttpHeader]): Self

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (HttpRequestOrResponse[F], B)

final def ==(arg0: Any): Boolean

def appendHeader(header: HttpHeader, headers: HttpHeader*): Self

appends supplied headers *

final def asInstanceOf[T0]: T0

def bodyAs[A](implicit D: BodyDecoder[A], F: Sync[F]): F[Attempt[A]]

Decodes body with supplied decoder of A *

def bodyAsByteVectorStream: Stream[F, ByteVector]

gets body as stream of byteVectors *

def bodyAsString(implicit F: Sync[F]): F[Attempt[String]]

decodes body as string with encoding supplied in ContentType *

lazy val bodyIsChunked: Boolean

yields to true, if body of this request shall be chunked *

def bodySize: Option[Long]

gets body size, if one specified *

def chunkedEncoding: Self

configures encoding as chunked *

def clone(): AnyRef

def contentType: Option[ContentType]

gets ContentType, if one specififed *

def ensuring(cond: (HttpRequestOrResponse[F]) ⇒ Boolean, msg: ⇒ Any): HttpRequestOrResponse[F]

def ensuring(cond: (HttpRequestOrResponse[F]) ⇒ Boolean): HttpRequestOrResponse[F]

def ensuring(cond: Boolean, msg: ⇒ Any): HttpRequestOrResponse[F]

def ensuring(cond: Boolean): HttpRequestOrResponse[F]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withBody[A](a: A)(implicit W: BodyEncoder[A]): Self

encodes body A given BodyEncoder exists *

def withBodySize(sz: Long): Self

sets body size to supplied value *

def withContentType(ct: ContentType): Self

updates content type to one specified *

def withHeader(header: HttpHeader, headers: HttpHeader*): Self

appends supplied headers.

def withHeaders[A](f: (List[HttpHeader]) ⇒ A): A

def withStreamBody[A](body: Stream[F, A])(implicit E: StreamBodyEncoder[F, A]): Self

allows to stream arbitrary sized stream of A to remote party (i.e.

def withStreamBody1[A](a: ⇒ A)(implicit E: StreamBodyEncoder[F, A]): Self

like stream except one A that is streamed lazily *

def withUtf8Body(s: String): Self

encodes body as utf8 string *

def →[B](y: B): (HttpRequestOrResponse[F], B)