Response

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addCookie(name: String, content: String, expires: Option[HttpDate] = None): Self

Add a `Set-Cookie` header with the provided values

def addCookie(cookie: ResponseCookie): Self

Add a Set-Cookie header for the provided ResponseCookie

def as[A](implicit F: MonadError[F, Throwable], decoder: EntityDecoder[F, A]): F[A]

Decode the Message to the specified type

final def asInstanceOf[T0]: T0

def attemptAs[T](implicit decoder: EntityDecoder[F, T]): DecodeResult[F, T]

Decode the Message to the specified type

val attributes: Vault

Vault containing additional parameters which may be used by the http4s backend for additional processing such as java.io.File object

val body: EntityBody[F]

EntityBody[F] representing the possible body of the response

def bodyAsText(implicit defaultCharset: Charset = DefaultCharset): Stream[F, String]

def change(httpVersion: HttpVersion, body: EntityBody[F], headers: Headers, attributes: Vault): Self

def charset: Option[Charset]

Returns the charset parameter of the Content-Type header, if present.

def clone(): AnyRef

def contentLength: Option[Long]

def contentType: Option[Content-Type]

def cookies: List[ResponseCookie]

Returns a list of cookies from the `Set-Cookie` headers.

final def eq(arg0: AnyRef): Boolean

def filterHeaders(f: (Header) ⇒ Boolean): Self

Keep headers that satisfy the predicate

def finalize(): Unit

final def getClass(): Class[_]

val headers: Headers

Headers containing all response headers

val httpVersion: HttpVersion

def isChunked: Boolean

final def isInstanceOf[T0]: Boolean

def mapK[G[_]](f: ~>[F, G]): Response[G]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def putHeaders(headers: Header*): Self

Add the provided headers to the existing headers, replacing those of the same header name The passed headers are assumed to contain no duplicate Singleton headers.

def removeCookie(name: String): Self

Add a `Set-Cookie` which will remove the specified cookie from the client

def removeCookie(cookie: ResponseCookie): Self

Add a `Set-Cookie` which will remove the specified cookie from the client

def removeHeader(key: HeaderKey): Self

val status: Status

Status code and message

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

def toString(): String

def trailerHeaders(implicit F: Applicative[F]): F[Headers]

The trailer headers, as specified in Section 3.6.1 of RFC 2616.

def transformHeaders(f: (Headers) ⇒ Headers): Self

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withAttribute[A](key: Key[A], value: A): Self

Generates a new message object with the specified key/value pair appended to the AttributeMap

def withAttributes(attributes: Vault): Self

def withBodyStream(body: EntityBody[F]): Self

Sets the entity body without affecting headers such as Transfer-Encoding or Content-Length.

def withContentType(contentType: Content-Type): Self

def withContentTypeOption(contentTypeO: Option[Content-Type]): Self

def withEmptyBody: Self

Set an empty entity body on this message, and remove all payload headers that make no sense with an empty body.

def withEntity[T](b: T)(implicit w: EntityEncoder[F, T]): Self

Replace the body of this message with a new body

def withHeaders(headers: Header*): Self

def withHeaders(headers: Headers): Self

def withHttpVersion(httpVersion: HttpVersion): Self

def withStatus(status: Status): Self

def withTrailerHeaders(trailerHeaders: F[Headers]): Self

def withoutAttribute(key: Key[_]): Self

Returns a new message object without the specified key in the AttributeMap

def withoutContentType: Self

def withoutTrailerHeaders: Self

def replaceAllHeaders(headers: Header*): Self

Replace the existing headers with those provided

def replaceAllHeaders(headers: Headers): Self

Replace the existing headers with those provided

def withBody[T](b: T)(implicit F: Applicative[F], w: EntityEncoder[F, T]): F[Self]

def withType(t: MediaType)(implicit F: Functor[F]): Self