ScalaVertex

final def !=(arg0: Any): Boolean

final def ##(): Int

def ---[CC <: Product](cc: CC)(implicit arg0: Marshallable[CC]): SemiEdge

def ---(label: String, properties: Map[String, Any]): SemiEdge

def ---(label: String, properties: KeyValue[_]*): SemiEdge

def ---(label: String): SemiEdge

def <--(de: SemiDoubleEdge)(implicit graph: ScalaGraph): (Edge, Edge)

implicit ScalaGraph required for configuration, e.g.

def <--(se: SemiEdge)(implicit graph: ScalaGraph): Edge

implicit ScalaGraph required for configuration, e.g.

final def ==(arg0: Any): Boolean

def addEdge[CC <: Product](inVertex: Vertex, cc: CC)(implicit arg0: Marshallable[CC]): Edge

def addEdge(label: String, inVertex: Vertex, properties: KeyValue[_]*)(implicit graph: ScalaGraph): Edge

implicit ScalaGraph required for configuration, e.g.

final def asInstanceOf[T0]: T0

def both(labels: String*): GremlinScala[org.apache.tinkerpop.gremlin.structure.Vertex] { type Labels = shapeless.HNil }

def both(): GremlinScala[org.apache.tinkerpop.gremlin.structure.Vertex] { type Labels = shapeless.HNil }

def bothE(labels: String*): GremlinScala[org.apache.tinkerpop.gremlin.structure.Edge] { type Labels = shapeless.HNil }

def bothE(): GremlinScala[org.apache.tinkerpop.gremlin.structure.Edge] { type Labels = shapeless.HNil }

def clone(): AnyRef

def edges(direction: Direction, edgeLabels: String*): Iterator[Edge]

def element: Vertex

final def eq(arg0: AnyRef): Boolean

final def getClass(): Class[_]

def graph: ScalaGraph

def id[A](implicit arg0: DefaultsToAny[A]): A

def in(labels: String*): GremlinScala[org.apache.tinkerpop.gremlin.structure.Vertex] { type Labels = shapeless.HNil }

def in(): GremlinScala[org.apache.tinkerpop.gremlin.structure.Vertex] { type Labels = shapeless.HNil }

def inE(labels: String*): GremlinScala[org.apache.tinkerpop.gremlin.structure.Edge] { type Labels = shapeless.HNil }

def inE(): GremlinScala[org.apache.tinkerpop.gremlin.structure.Edge] { type Labels = shapeless.HNil }

final def isInstanceOf[T0]: Boolean

def keys: Set[Key[Any]]

def label: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def out(labels: String*): GremlinScala[org.apache.tinkerpop.gremlin.structure.Vertex] { type Labels = shapeless.HNil }

def out(): GremlinScala[org.apache.tinkerpop.gremlin.structure.Vertex] { type Labels = shapeless.HNil }

def outE(labels: String*): GremlinScala[org.apache.tinkerpop.gremlin.structure.Edge] { type Labels = shapeless.HNil }

def outE(): GremlinScala[org.apache.tinkerpop.gremlin.structure.Edge] { type Labels = shapeless.HNil }

def properties[A](wantedKeys: String*)(implicit arg0: DefaultsToAny[A]): Stream[VertexProperty[A]]

def properties[A](implicit arg0: DefaultsToAny[A]): Stream[VertexProperty[A]]

def property[A](cardinality: Cardinality, key: Key[A], value: A, keyValues: AnyRef*): VertexProperty[A]

def property[A](key: Key[A]): Property[A]

def removeProperties(keys: Key[_]*): Vertex

def removeProperty(key: Key[_], cardinality: Cardinality): Vertex

def removeProperty(key: Key[_]): Vertex

def setProperties[CC <: Product](cc: CC)(implicit arg0: Marshallable[CC]): Vertex

def setProperties(properties: Map[Key[Any], Any]): Vertex

def setProperty[A](key: Key[A], value: A): Vertex

def setPropertyList[A <: AnyRef](key: Key[A], values: List[A]): VertexProperty[A]

def setPropertyList[A <: AnyRef](key: String, values: List[A]): VertexProperty[A]

convenience function for property which normally requires to pass in key/value pairs as varargs

def start(configure: (TraversalSource) ⇒ TraversalSource): Aux[Vertex, HNil]

start a new traversal from this element and configure it

def start(): Aux[Vertex, HNil]

start a new traversal from this element

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

def toCC[CC <: Product](implicit arg0: Marshallable[CC]): CC

def updateAs[CC <: Product](f: (CC) ⇒ CC)(implicit arg0: Marshallable[CC]): Vertex

def updateWith[CC <: Product](update: CC)(implicit arg0: Marshallable[CC]): Vertex

def value[A](key: String)(implicit arg0: DefaultsToAny[A]): A

def value2[A](key: Key[A]): A

def valueMap[A](keys: String*)(implicit arg0: DefaultsToAny[A]): Map[String, A]

def valueMap[A](implicit arg0: DefaultsToAny[A]): Map[String, A]

def valueOption[A](key: Key[A], value: Option[A]): Vertex

def valueOption[A](key: Key[A]): Option[A]

def valueOption[A](key: String)(implicit arg0: DefaultsToAny[A]): Option[A]

def values[A](keys: String*)(implicit arg0: DefaultsToAny[A]): Iterator[A]

val vertex: Vertex

def vertices(direction: Direction, edgeLabels: String*): Iterator[Vertex]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit