RemoteGraph

abstract def cache: Graph

abstract def iri: String

abstract def service: LinkedDataService

final def !=(arg0: Any): Boolean

final def ##(): Int

final def +(label: Ontology): Node

def ++(graph: Graph): Unit

final def ==(arg0: Any): Boolean

def __[Start, End](implicit cltblStart: ClassTypeable[Start], cltblEnd: ClassTypeable[End]): Traversal[CT, CT, HNil]

def _createEdge[S, E](id: Long)(from: Resource[S], key: Property, to: Resource[E]): Edge[S, E]

def _deleteEdge(edge: Edge[_, _]): Unit

def _deleteNode(node: Node): Unit

def _deleteValue(value: Value[_]): Unit

def add(graph: Graph): Unit

final def asInstanceOf[T0]: T0

def buildAsyncTraversersStream[ST <: ClassType[_], ET <: ClassType[_], Steps <: HList, Out](traversal: Traversal[ST, ET, Steps]): Task[Stream[Out]]

def buildTraversersStream[ST <: ClassType[_], ET <: ClassType[_], Steps <: HList, Out](traversal: Traversal[ST, ET, Steps]): Stream[Out]

def clone(): AnyRef

def close(): CancelableFuture[Unit]

def createEdge[S, E](id: Long, from: GResource[S], key: Property, to: GResource[E]): GEdge[S, E]

def createEdge(id: Long, from: Long, key: Property, to: Long): GEdge[Any, Any]

def createValue[T](id: Long, value: T, dt: DataType[T]): GValue[T]

def deleteEdge(edge: GEdge[_, _]): Unit

def deleteNode(node: GNode): Unit

def deleteResource[T <: _Resource[_]](resource: T): Unit

def deleteValue(value: GValue[_]): Unit

def edgeStore: EdgeStore[RemoteGraph.this.type]

def edges: Edges

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

def finalize(): Unit

def g(graph: Graph*): Traversal[DataType[Graph], DataType[Graph], HNil]

def g: Traversal[DataType[Graph], DataType[Graph], HNil]

final def getClass(): Class[_]

def getOrCreateNode(id: Long): GNode

lazy val hashCode: Int

lazy val idProvider: IdProvider

lazy val init: CancelableFuture[Unit]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def newEdge[S, E](id: Long, from: GResource[S], key: Property, to: GResource[E]): GEdge[S, E]

def newEdge(id: Long, from: Long, key: Property, to: Long): GEdge[Any, Any]

def newNode(id: Long): GNode

def newValue[T](id: Long, value: T, label: DataType[T]): GValue[T]

def nodeStore: NodeStore[RemoteGraph.this.type]

def nodes: Nodes

final def notify(): Unit

final def notifyAll(): Unit

lazy val ns: NameSpaceGraph

def persist: CancelableFuture[Unit]

def resources: Resources

def storeEdge(edge: GEdge[_, _]): Unit

def storeNode(node: GNode): Unit

def storeValue(value: GValue[_]): Unit

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

lazy val thisgraph: RemoteGraph.this.type

def toString(): String

def transaction: Transaction

creates new transaction

lazy val traversal: Traversal[DataType[Graph], DataType[Graph], HNil]

def valueStore: ValueStore[RemoteGraph.this.type]

def values: Values

final def wait(): Unit

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

final def wait(arg0: Long): Unit