NameSpaceService

implicit abstract def baseDecoder: Aux[Json]

implicit abstract def baseEncoder: Aux[Json]

abstract def graph: structure.Graph

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val api: Endpoint[IO, :+:[String, :+:[String, CNil]]]

final def asInstanceOf[T0]: T0

def binaryBody(implicit F: Sync[IO]): Endpoint[IO, Array[Byte]]

def binaryBodyOption(implicit F: Sync[IO]): Endpoint[IO, Option[Array[Byte]]]

def binaryBodyStream[S[_[_], _]](implicit F: Sync[IO], LR: LiftReader[S, IO]): Endpoint[IO, S[IO, Array[Byte]]]

def body[A, CT](implicit arg0: ClassTag[A], D: Dispatchable[A, CT], F: Sync[IO]): Endpoint[IO, A]

def bodyOption[A, CT](implicit arg0: ClassTag[A], F: Sync[IO], D: Dispatchable[A, CT]): Endpoint[IO, Option[A]]

def bodyStream[S[_[_], _], A, CT <: String](implicit F: Sync[IO], LR: LiftReader[S, IO], A: Aux[S, IO, A, CT]): Endpoint[IO, S[IO, A]]

val byIri: Endpoint[IO, String]

val cache: HashMap[String, HashMap[String, String]]

def classpathAsset(path: String)(implicit F: Sync[IO], S: ContextShift[IO]): Endpoint[IO, Buf]

def clone(): AnyRef

def const[A](a: A)(implicit F: Applicative[IO]): Endpoint[IO, A]

def cookie(name: String)(implicit F: Sync[IO]): Endpoint[IO, Cookie]

def cookieOption(name: String)(implicit F: Sync[IO]): Endpoint[IO, Option[Cookie]]

def delete[A](e: Endpoint[IO, A]): Mappable[IO, A]

def empty[A]: Endpoint[IO, A]

val encoder: Encoder

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filesystemAsset(path: String)(implicit F: Sync[IO], S: ContextShift[IO]): Endpoint[IO, Buf]

def finalize(): Unit

def fromFile(file: File)(implicit F: Sync[IO], S: ContextShift[IO]): Endpoint[IO, Buf]

def fromInputStream(stream: cats.effect.Resource[IO, InputStream])(implicit F: Sync[IO], S: ContextShift[IO]): Endpoint[IO, Buf]

def get[A](e: Endpoint[IO, A]): Mappable[IO, A]

final def getClass(): Class[_]

val getResource: Endpoint[IO, String]

retrieve a single resource

def hashCode(): Int

def head[A](e: Endpoint[IO, A]): Mappable[IO, A]

def header[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, A]

def headerOption[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, Option[A]]

val headersAll: Endpoint[IO, Map[String, String]]

final def isInstanceOf[T0]: Boolean

def jsonBody[A](implicit arg0: io.finch.Decode.Json[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, A]

def jsonBodyOption[A](implicit arg0: io.finch.Decode.Json[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, Option[A]]

def jsonBodyStream[S[_[_], _], A](implicit F: Sync[IO], LR: LiftReader[S, IO], A: Aux[S, IO, A, io.finch.Application.Json]): Endpoint[IO, S[IO, A]]

def lift[A](a: ⇒ A)(implicit F: Sync[IO]): Endpoint[IO, A]

def liftAsync[A](fa: ⇒ IO[A])(implicit F: Sync[IO]): Endpoint[IO, A]

def liftOutput[A](oa: ⇒ Output[A])(implicit F: Sync[IO]): Endpoint[IO, A]

def liftOutputAsync[A](foa: ⇒ IO[Output[A]])(implicit F: Sync[IO]): Endpoint[IO, A]

def multipartAttribute[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, A]

def multipartAttributeOption[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, Option[A]]

def multipartAttributes[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, List[A]]

def multipartAttributesNel[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, NonEmptyList[A]]

def multipartFileUpload(name: String)(implicit F: Sync[IO]): Endpoint[IO, FileUpload]

def multipartFileUploadOption(name: String)(implicit F: Sync[IO]): Endpoint[IO, Option[FileUpload]]

def multipartFileUploads(name: String)(implicit F: Sync[IO]): Endpoint[IO, List[FileUpload]]

def multipartFileUploadsNel(name: String)(implicit F: Sync[IO]): Endpoint[IO, NonEmptyList[FileUpload]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def options[A](e: Endpoint[IO, A]): Mappable[IO, A]

def param[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, A]

def paramOption[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, Option[A]]

def params[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, List[A]]

def paramsNel[A](name: String)(implicit arg0: DecodeEntity[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, NonEmptyList[A]]

def patch[A](e: Endpoint[IO, A]): Mappable[IO, A]

implicit def path(s: String)(implicit F: Sync[IO]): Endpoint[IO, HNil]

def path[A](implicit arg0: DecodePath[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, A]

def pathAny(implicit F: Applicative[IO]): Endpoint[IO, HNil]

def pathEmpty(implicit F: Applicative[IO]): Endpoint[IO, HNil]

def paths[A](implicit arg0: DecodePath[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, List[A]]

def post[A](e: Endpoint[IO, A]): Mappable[IO, A]

def put[A](e: Endpoint[IO, A]): Mappable[IO, A]

def root(implicit F: Sync[IO]): Endpoint[IO, Request]

def stringBody(implicit F: Sync[IO]): Endpoint[IO, String]

def stringBodyOption(implicit F: Sync[IO]): Endpoint[IO, Option[String]]

def stringBodyStream[S[_[_], _]](implicit F: Sync[IO], LR: LiftReader[S, IO]): Endpoint[IO, S[IO, String]]

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

def textBody[A](implicit arg0: Text[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, A]

def textBodyOption[A](implicit arg0: Text[A], arg1: ClassTag[A], F: Sync[IO]): Endpoint[IO, Option[A]]

def textBodyStream[S[_[_], _], A](implicit F: Sync[IO], LR: LiftReader[S, IO], A: Aux[S, IO, A, Plain]): Endpoint[IO, S[IO, A]]

def toString(): String

def trace[A](e: Endpoint[IO, A]): Mappable[IO, A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zero(implicit F: Applicative[IO]): Endpoint[IO, HNil]