rho

abstract def getClass(): Class[_]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit val HttpVersionOrder: Order[HttpVersion]

implicit val HttpVersionShow: Show[HttpVersion]

val PathEmpty: PathRule

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 F: Sync[F]): EntityDecoder[F, File]

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

implicit def binaryChunk[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): EntityEncoder[F, Array[Char]]

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

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]]

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

def equals(arg0: Any): Boolean

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

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

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

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

package hal

Describes Hypertext Application Language types and functions

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 def http4sNonEmptyListSyntax[A](l: NonEmptyList[A]): NonEmptyListOps[A]

implicit val http4sShowForCharsetRange: Show[Charset]

implicit val http4sShowForMethod: Show[Method]

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]]

macro def q(d: Double): QValue

implicit val qValueHttpCodec: HttpCodec[QValue]

implicit val qValueOrder: Order[QValue]

implicit val qValueShow: Show[QValue]

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

def removeDotSegments(path: Path): Path

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

implicit def segmentEncoder[F[_]](implicit arg0: Applicative[F]): EntityEncoder[F, Segment[Byte, Unit]]

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

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

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

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

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

def textFile[F[_]](file: File)(implicit 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

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

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

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