Http4s

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit val HttpVersionOrder: Order[HttpVersion]

implicit val HttpVersionShow: Show[HttpVersion]

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, blockingExecutionContext: ExecutionContext)(implicit F: Sync[F], cs: ContextShift[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[_]]: EntityEncoder[F, Array[Byte]]

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

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

implicit def chunkEncoder[F[_]]: EntityEncoder[F, Chunk[Byte]]

def clone(): AnyRef

def emptyEncoder[F[_], A]: EntityEncoder[F, A]

implicit def entityBodyEncoder[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

def fileEncoder[F[_]](blockingExecutionContext: ExecutionContext)(implicit F: Effect[F], cs: ContextShift[F]): EntityEncoder[F, File]

def filePathEncoder[F[_]](blockingExecutionContext: ExecutionContext)(implicit arg0: Sync[F], arg1: ContextShift[F]): EntityEncoder[F, Path]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

implicit val http4sEqForCharsetRange: Eq[CharsetRange]

implicit val http4sEqForMethod: Eq[Method]

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

implicit def http4sLiteralsSyntax(sc: StringContext): LiteralsOps

implicit val http4sShowForCharsetRange: Show[Charset]

implicit val http4sShowForMethod: Show[Method]

implicit def http4sStringSyntax(s: String): StringOps

def inputStreamEncoder[F[_], IS <: InputStream](blockingExecutionContext: ExecutionContext)(implicit arg0: Sync[F], arg1: ContextShift[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[_]]: 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 qValueHttpCodec: HttpCodec[QValue]

implicit val qValueOrder: Order[QValue]

implicit val qValueShow: Show[QValue]

implicit def readerEncoder[F[_], R <: Reader](blockingExecutionContext: ExecutionContext)(implicit F: Sync[F], cs: ContextShift[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[_]]: EntityEncoder[F, EventStream[F]]

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

Encodes a value from its Show instance.

implicit def streamEncoder[F[_], A](implicit 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 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, blockingExecutionContext: ExecutionContext)(implicit F: Sync[F], cs: ContextShift[F]): EntityDecoder[F, File]

def toString(): String

implicit def unitEncoder[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

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

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

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

implicit def http4sNonEmptyListSyntax[A](l: NonEmptyList[A]): NonEmptyListOps[A]