FilterStepsHelper

abstract def _traversal: Traversal[ST[Start], ET[End], Steps]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def add[S <: Step, ST <: structure.ClassType[Any], ET <: structure.ClassType[Any]](step: S, st: ST, et: ET): Traversal[ST, ET, ::[S, Steps]]

def add[S <: Step](step: S): Traversal[ST[Start], ET[End], ::[S, Steps]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

def constant[T, T0, TT0 <: structure.ClassType[_]](p: T)(implicit ct: Aux[T, T0, TT0]): Traversal[ST[Start], TT0, ::[Constant[T], Steps]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def et: ET[End]

def finalize(): Unit

final def getClass(): Class[_]

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

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

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

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

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

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

has at least one of the provided iris

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

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

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

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

has at least one of the provided labels

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

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

def hasLabels[ET0 <: structure.ClassType[_], End1, ET1 <: structure.ClassType[_]](label0: ET0, label1: ET0)(implicit et: Aux[ET0, End1, ET1]): Traversal[ST[Start], ET1, ::[HasLabel, Steps]]

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

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

def hashCode(): Int

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

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

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

final def isInstanceOf[T0]: Boolean

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

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

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def st: ST[Start]

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