Http4s

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit val CharacterSetEqual: Eq[CharsetRange]

implicit val CharsetShow: Show[Charset]

implicit val HttpVersionOrder: Order[HttpVersion]

implicit val HttpVersionShow: Show[HttpVersion]

implicit val MethodInstances: Show[Method] with Eq[Method]

implicit val StatusOrder: Order[Status]

implicit val StatusShow: Show[Status]

final def asInstanceOf[T0]: T0

implicit def asyncSyntax[F[_], A](async: Async[F]): AsyncOps[F, A]

def binFile[F[_]](file: File)(implicit arg0: MonadError[F, Throwable], F: Sync[F]): EntityDecoder[F, File]

implicit def binary[F[_]](implicit arg0: Sync[F]): EntityDecoder[F, Chunk[Byte]]

implicit def byteArrayDecoder[F[_]](implicit arg0: Sync[F]): EntityDecoder[F, Array[Byte]]

implicit def byteArrayEncoder[F[_]](implicit arg0: Applicative[F]): EntityEncoder[F, Array[Byte]]

implicit def charArrayDecoder[F[_]](implicit arg0: Sync[F]): EntityDecoder[F, Array[Char]]

implicit def charArrayEncoder[F[_]](implicit F: Applicative[F], charset: Charset = DefaultCharset): EntityEncoder[F, Array[Char]]

implicit def chunkEncoder[F[_]](implicit arg0: Applicative[F]): EntityEncoder[F, Chunk[Byte]]

def clone(): AnyRef

implicit def effectEncoder[F[_], A](implicit F: FlatMap[F], W: EntityEncoder[F, A]): EntityEncoder[F, F[A]]

def emptyEncoder[F[_], A](implicit F: Applicative[F]): EntityEncoder[F, A]

implicit def entityBodyEncoder[F[_]](implicit F: Applicative[F]): EntityEncoder[F, EntityBody[F]]

Encodes an entity body.

implicit def entityEncoderContravariant[F[_]]: Contravariant[[β$0$]EntityEncoder[F, β$0$]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error[F[_], T](t: Throwable)(implicit F: Sync[F]): EntityDecoder[F, T]

Provides a mechanism to fail decoding

implicit def fileEncoder[F[_]](implicit F: Sync[F]): EntityEncoder[F, File]

implicit def filePathEncoder[F[_]](implicit arg0: Sync[F]): EntityEncoder[F, Path]

def finalize(): Unit

implicit def futureEncoder[F[_], A](implicit F: Async[F], ec: ExecutionContext, W: EntityEncoder[F, A]): EntityEncoder[F, Future[A]]

final def getClass(): Class[_]

def hashCode(): Int

implicit def http4sKleisliResponseSyntax[F[_], A](service: Kleisli[[β$0$]OptionT[F, β$0$], A, Response[F]])(implicit arg0: Functor[F]): KleisliResponseOps[F, A]

implicit def http4sStringSyntax(s: String): StringOps

implicit def inputStreamEncoder[F[_], IS <: InputStream](implicit arg0: Sync[F]): EntityEncoder[F, F[IS]]

final def isInstanceOf[T0]: Boolean

implicit def multipart[F[_]](implicit arg0: Sync[F]): EntityDecoder[F, Multipart[F]]

implicit def multipartEncoder[F[_]](implicit arg0: Sync[F]): EntityEncoder[F, Multipart[F]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

macro def q(d: Double): QValue

Supports a literal syntax for validated QValues.

q(0.5).success == QValue.fromDouble(0.5)
q(1.1) // does not compile: out of range
val d = 0.5
q(d) // does not compile: not a literal

implicit val qValueOrder: Order[QValue]

implicit val qValueShow: Show[QValue]

implicit def readerEncoder[F[_], R <: Reader](implicit F: Sync[F], charset: Charset = DefaultCharset): EntityEncoder[F, F[R]]

def removeDotSegments(path: Path): Path

Remove dot sequences from a Path, per RFC 3986 Sec 5.2.4

def resolve(base: Uri, reference: Uri): Uri

Resolve a relative Uri reference, per RFC 3986 sec 5.2

implicit def serverSentEventEncoder[F[_]](implicit arg0: Applicative[F]): EntityEncoder[F, EventStream[F]]

def showEncoder[F[_], A](implicit arg0: Applicative[F], charset: Charset = DefaultCharset, show: Show[A]): EntityEncoder[F, A]

Encodes a value from its Show instance.

implicit def streamEncoder[F[_], A](implicit F: Applicative[F], W: EntityEncoder[F, A]): EntityEncoder[F, Stream[F, A]]

A stream encoder is intended for streaming, and does not calculate its bodies in advance.

implicit def stringEncoder[F[_]](implicit F: Applicative[F], charset: Charset = DefaultCharset): EntityEncoder[F, String]

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

implicit def text[F[_]](implicit arg0: Sync[F], defaultCharset: Charset = DefaultCharset): EntityDecoder[F, String]

def textFile[F[_]](file: File)(implicit arg0: MonadError[F, Throwable], F: Sync[F]): EntityDecoder[F, File]

def toString(): String

implicit def unitEncoder[F[_]](implicit arg0: Applicative[F]): EntityEncoder[F, Unit]

macro def uri(s: String): Uri

Literal syntax for URIs.

implicit def void[F[_]](implicit arg0: Sync[F]): EntityDecoder[F, Unit]

An entity decoder that ignores the content and returns unit.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

implicit def http4sEffectRequestSyntax[F[_]](req: F[Request[F]]): EffectRequestOps[F]

implicit def http4sEffectResponseSyntax[F[_]](resp: F[Response[F]]): EffectResponseOps[F]