Served

abstract def is: Fragments

abstract def setup: (Http) ⇒ Http

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

implicit def RegexFragmentToFragments(r: RegexFragment): Fragments

def after: Unit

implicit def argumentsFragment(a: Arguments): FragmentsFragment

final def asInstanceOf[T0]: T0

def before: netty.Server.ServerBuilder

def clone(): AnyRef

implicit def downcastGiven[X, Y <: X](gv: Given[Y]): Given[X] { def extract(s: String): Y }

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def exampleFactory: ExampleFactory

lazy val executor: ExecutorService

def finalize(): Unit

implicit def forExample(s: String): ExampleDesc

implicit def fragmentFragments(f: ⇒ Fragment): FragmentsFragment

implicit def fragments(f: ⇒ Fragment): Fragments

implicit def fragmentsFragmentToFragments(fs: FragmentsFragment): Fragments

implicit def fragmentsFragments(fs: ⇒ Fragments): FragmentsFragment

final def getClass(): Class[_]

def groupAs(groupRegex: String): ReadAs

def hashCode(): Int

val host: Request

def http[T](handler: Handler[T]): T

Silent, resource-managed http request executor

def identification: SpecIdentification

implicit def identifySpecificationStructure(s: SpecificationStructure): SpecIdentification

implicit lazy val implicitParam: ImplicitParam

implicit lazy val implicitParam1: ImplicitParam1

implicit lazy val implicitParam10: ImplicitParam10

implicit lazy val implicitParam2: ImplicitParam2

implicit lazy val implicitParam3: ImplicitParam3

implicit lazy val implicitParam4: ImplicitParam4

implicit lazy val implicitParam5: ImplicitParam5

implicit lazy val implicitParam6: ImplicitParam6

implicit lazy val implicitParam7: ImplicitParam7

implicit lazy val implicitParam8: ImplicitParam8

implicit lazy val implicitParam9: ImplicitParam9

implicit def inScope(s: Scope): Success

def include(args: Arguments, f: Fragments, fs: Fragments*): FragmentsFragment

def include(args: Arguments, f: Fragments): FragmentsFragment

def include(args: Arguments, s: SpecificationStructure, ss: SpecificationStructure*): FragmentsFragment

def include(args: Arguments, s: SpecificationStructure): FragmentsFragment

def include(s: SpecificationStructure, ss: SpecificationStructure*): FragmentsFragment

implicit def include(s: SpecificationStructure): FragmentsFragment

def include(f: Fragments, fs: Fragments*): FragmentsFragment

def include(f: Fragments): FragmentsFragment

def inline(specs: SpecificationStructure*): Fragments

final def isInstanceOf[T0]: Boolean

def link(htmlLink: HtmlLink, f: Fragments): Fragments

def link(htmlLink: HtmlLink, s: SpecificationStructure): Fragments

def link(fss: Seq[Fragments]): Fragments

def link(fs: Fragments, fss: Fragments*): Fragments

def link(fs: Fragments): Fragments

def link(ss: Seq[SpecificationStructure], dummy: Int): Fragments

def link(s: SpecificationStructure, ss: SpecificationStructure*): Fragments

def link(s: SpecificationStructure): Fragments

def logHttpRequests: Boolean

def map(fs: ⇒ Fragments): Fragments

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def planify(intentIn: Intent): SimpleChannelUpstreamHandler with Plan with DeferralExecutor with DeferredIntent with ServerErrorResponse { val intent: unfiltered.netty.cycle.Plan.Intent }

planify using a local executor.

val port: Int

def readAs(regex: String): ReadAs

implicit def scopeAsResult[S <: Scope]: AsResult[S]

def see(htmlLink: HtmlLink, fs: Fragments): Fragments

def see(htmlLink: HtmlLink, s: SpecificationStructure): Fragments

def see(fss: Seq[Fragments]): Fragments

def see(fs: Fragments, fss: Fragments*): Fragments

def see(fs: Fragments): Fragments

def see(s: SpecificationStructure): Fragments

def see(ss: Seq[SpecificationStructure])(implicit p1: ImplicitParam1): Fragments

def see(s: SpecificationStructure, ss: SpecificationStructure*): Fragments

lazy val server: Http

implicit def specIdentificationMarkdownLink(s: String): SpecIdentificationMarkdownLink

implicit def specificationStructureToFragments(s: SpecificationStructure): AsFragments

implicit def stringToHtmlLinkFragments(s: String): HtmlLinkFragments

implicit def stringToHtmlLinkFragments2(s: String): HtmlLinkFragments2

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

implicit def textFragment(s: String): FragmentsFragment

implicit def textStart(s: String): Fragments

implicit def title(s: String): SpecTitle

def toString(): String

implicit def tupleToSeq10[T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](t: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10))(implicit e1: <:<[T1, T], e2: <:<[T2, T], e3: <:<[T3, T], e4: <:<[T4, T], e5: <:<[T5, T], e6: <:<[T6, T], e7: <:<[T7, T], e8: <:<[T8, T], e9: <:<[T9, T], e10: <:<[T10, T]): Seq[T]

implicit def tupleToSeq2[T, T1, T2](t: (T1, T2))(implicit e1: <:<[T1, T], e2: <:<[T2, T]): Seq[T]

implicit def tupleToSeq3[T, T1, T2, T3](t: (T1, T2, T3))(implicit e1: <:<[T1, T], e2: <:<[T2, T], e3: <:<[T3, T]): Seq[T]

implicit def tupleToSeq4[T, T1, T2, T3, T4](t: (T1, T2, T3, T4))(implicit e1: <:<[T1, T], e2: <:<[T2, T], e3: <:<[T3, T], e4: <:<[T4, T]): Seq[T]

implicit def tupleToSeq5[T, T1, T2, T3, T4, T5](t: (T1, T2, T3, T4, T5))(implicit e1: <:<[T1, T], e2: <:<[T2, T], e3: <:<[T3, T], e4: <:<[T4, T], e5: <:<[T5, T]): Seq[T]

implicit def tupleToSeq6[T, T1, T2, T3, T4, T5, T6](t: (T1, T2, T3, T4, T5, T6))(implicit e1: <:<[T1, T], e2: <:<[T2, T], e3: <:<[T3, T], e4: <:<[T4, T], e5: <:<[T5, T], e6: <:<[T6, T]): Seq[T]

implicit def tupleToSeq7[T, T1, T2, T3, T4, T5, T6, T7](t: (T1, T2, T3, T4, T5, T6, T7))(implicit e1: <:<[T1, T], e2: <:<[T2, T], e3: <:<[T3, T], e4: <:<[T4, T], e5: <:<[T5, T], e6: <:<[T6, T], e7: <:<[T7, T]): Seq[T]

implicit def tupleToSeq8[T, T1, T2, T3, T4, T5, T6, T7, T8](t: (T1, T2, T3, T4, T5, T6, T7, T8))(implicit e1: <:<[T1, T], e2: <:<[T2, T], e3: <:<[T3, T], e4: <:<[T4, T], e5: <:<[T5, T], e6: <:<[T6, T], e7: <:<[T7, T], e8: <:<[T8, T]): Seq[T]

implicit def tupleToSeq9[T, T1, T2, T3, T4, T5, T6, T7, T8, T9](t: (T1, T2, T3, T4, T5, T6, T7, T8, T9))(implicit e1: <:<[T1, T], e2: <:<[T2, T], e3: <:<[T3, T], e4: <:<[T4, T], e5: <:<[T5, T], e6: <:<[T6, T], e7: <:<[T7, T], e8: <:<[T8, T], e9: <:<[T9, T]): Seq[T]

implicit def upcastThen[X, Y <: X](th: Then[X]): Then[Y]

implicit def updowncastWhen[P, Q, R <: P, S >: Q](wh: When[P, Q]): When[R, S]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def xhttp[T](handler: Handler[T]): T

Silent, resource-managed http request executor which accepts non-ok status