FilterStepsHelper

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[End], ::[Segment[::[S, HNil]], Segments1]]

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

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

abstract def et: ET[End]

abstract def st: ST[Start]

abstract def target: Graph

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def coin(p: Double): Traversal[ST[Start], ET[End], ::[Segment[::[Coin, Steps]], Segments]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def has[L, T](label: L, value: P[T])(implicit arg0: PropertyLabel[L]): Traversal[ST[Start], ET[End], ::[Segment[::[Has, Steps]], Segments]]

def has[L](label: L)(implicit arg0: PropertyLabel[L]): Traversal[ST[Start], ET[End], ::[Segment[::[Has, Steps]], Segments]]

def hasId(ids: Set[Long]): Traversal[ST[Start], ET[End], ::[Segment[::[HasId, Steps]], Segments]]

def hasId(id: Long, ids: Long*): Traversal[ST[Start], ET[End], ::[Segment[::[HasId, Steps]], Segments]]

def hasIri(iris: Set[String]): Traversal[ST[Start], ET[End], ::[Segment[::[HasIri, Steps]], Segments]]

def hasIri(iri: String, uris: String*): Traversal[ST[Start], ET[End], ::[Segment[::[HasIri, Steps]], Segments]]

has at least one of the provided iris

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

def hasLabel[A](implicit cls: ClassTypeable[A]): Traversal[ST[Start], CT, ::[Segment[::[HasLabel, Steps]], Segments]]

def hasLabel[T, ET0[+Z] <: ClassType[Z], End1, ET1 <: ClassType[_]](label0: ET0[T], label1: ET0[T], label2: ET0[T], label3: ET0[T])(implicit et: Aux[ET0[T], End1, ET1]): Traversal[ST[Start], ET1, ::[Segment[::[HasLabel, Steps]], Segments]]

def hasLabel[T, ET0[+Z] <: ClassType[Z], End1, ET1 <: ClassType[_]](label0: ET0[T], label1: ET0[T], label2: ET0[T])(implicit et: Aux[ET0[T], End1, ET1]): Traversal[ST[Start], ET1, ::[Segment[::[HasLabel, Steps]], Segments]]

def hasLabel[ET0 <: ClassType[_], End1, ET1 <: ClassType[_]](label0: ET0, label1: ET0)(implicit et: Aux[ET0, End1, ET1]): Traversal[ST[Start], ET1, ::[Segment[::[HasLabel, Steps]], Segments]]

def hasLabel[T <: DataType[_], End1, ET1 <: ClassType[_]](label: T)(implicit et: Aux[T, End1, ET1]): Traversal[ST[Start], ET1, ::[Segment[::[HasLabel, Steps]], Segments]]

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

def hasLabel(label: Ontology): Traversal[ST[Start], NodeURLType[Node], ::[Segment[::[HasLabel, Steps]], Segments]]

has at least one of the provided labels

def hasNot[L, T](label: L, value: P[T])(implicit arg0: PropertyLabel[L]): Traversal[ST[Start], ET[End], ::[Segment[::[HasNot, Steps]], Segments]]

def hasNot[L](label: L)(implicit arg0: PropertyLabel[L]): Traversal[ST[Start], ET[End], ::[Segment[::[HasNot, Steps]], Segments]]

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

def isColor: Traversal[ST[Start], ColorType[Any], ::[Segment[::[HasLabel, Steps]], Segments]]

def isDuration: Traversal[ST[Start], DurationType, ::[Segment[::[HasLabel, Steps]], Segments]]

def isGeo: Traversal[ST[Start], GeometricType[Geometry], ::[Segment[::[HasLabel, Steps]], Segments]]

final def isInstanceOf[T0]: Boolean

def isNumber: Traversal[ST[Start], NumericType[AnyVal], ::[Segment[::[HasLabel, Steps]], Segments]]

def isQuantity: Traversal[ST[Start], QuantityType[Any], ::[Segment[::[HasLabel, Steps]], Segments]]

def isTemporal: Traversal[ST[Start], CalendarType[Any], ::[Segment[::[HasLabel, Steps]], Segments]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit