EdgeStepsHelper

abstract def add[S <: ResourceStep, ST <: ClassType[_], ET <: ClassType[_]](step: S, st: ST, et: ET)(implicit ev: <:<[S, ResourceStep]): Traversal[ST, ET, ::[Segment[::[S, HNil]], Segments1]]

abstract def add[S <: MoveStep, ST <: ClassType[_], ET <: ClassType[_]](step: S, st: ST, et: ET)(implicit ev: <:<[S, MoveStep]): Traversal[ST, ET, ::[Segment[::[S, HNil]], Segments1]]

abstract def add[S <: Step, ST <: ClassType[_], ET <: ClassType[_]](step: S, st: ST, et: ET)(implicit ev: <:!<[S, MoveStep], ev2: <:!<[S, ResourceStep]): Traversal[ST, ET, ::[Segment[::[S, Steps]], Segments]]

abstract def add[S <: ResourceStep](step: S)(implicit ev: <:<[S, ResourceStep]): Traversal[ST[Start], ET[Edge[In, Out]], ::[Segment[::[S, HNil]], Segments1]]

abstract def add[S <: MoveStep](step: S)(implicit ev: <:<[S, MoveStep]): Traversal[ST[Start], ET[Edge[In, Out]], ::[Segment[::[S, HNil]], Segments1]]

abstract def add[S <: Step](step: S)(implicit ev: <:!<[S, MoveStep], ev2: <:!<[S, ResourceStep]): Traversal[ST[Start], ET[Edge[In, Out]], ::[Segment[::[S, Steps]], Segments]]

abstract def et: ET[Edge[In, Out]]

abstract def st: ST[Start]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def from[InC, InCT <: ClassType[InC]](implicit ct: Aux[In, InC, InCT]): Traversal[ST[Start], InCT, ::[Segment[::[From, HNil]], Segments1]]

final def getClass(): Class[_]

def hasLabel(label0: String, labels0: String*): Traversal[ST[Start], ET[Edge[In, Out]], ::[Segment[::[HasLabel, Steps]], Segments]]

def hasLabel(label: Property): Traversal[ST[Start], EdgeURLType[Edge[Any, Any]], ::[Segment[::[HasLabel, Steps]], Segments]]

this looks redundant w.r.t.

def hashCode(): Int

def id: Traversal[ST[Start], LongType[Long], ::[Segment[::[Id.type, HNil]], Segments1]]

def iri: Traversal[ST[Start], (defaultString)#CT, ::[Segment[::[HasLabel, ::[Out, HNil]]], Segments1]]

final def isInstanceOf[T0]: Boolean

def label(key: Property*): Traversal[ST[Start], IriType[Property], ::[Segment[::[Label, HNil]], Segments1]]

def label(keys: List[Property] = List()): Traversal[ST[Start], IriType[Property], ::[Segment[::[Label, HNil]], Segments1]]

def label(key: String, keys: String*): Traversal[ST[Start], IriType[Property], ::[Segment[::[Label, HNil]], Segments1]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def to[OutC, OutCT <: ClassType[OutC]](implicit ct: Aux[Out, OutC, OutCT]): Traversal[ST[Start], OutCT, ::[Segment[::[To, HNil]], Segments1]]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit