LTransaction

final def !=(arg0: Any): Boolean

final def ##(): Int

def *>[ST <: ClassType[_], ET <: ClassType[_], Segments <: HList, Steps <: HList, RSteps <: HList, Containers <: HList, F[_], Out, CT <: ClassType[Out], Out2](traversal: librarian.traversal.Traversal[ST, ET, Segments])(implicit flat: Aux[SegmentMapper.type, Segments, Steps], reverse: Aux[Steps, RSteps], f: Aux[RSteps, ContainerSteps.type, Containers], lf: Aux[Containers, ET, Out, CT], tw: Aux[ET, Out, Containers, Out2], guide: Guide[F], mapper: Mapper[F, Containers, Out]): FT

final def +(label: Ontology): Node

val ++: (structure.Graph) ⇒ structure.Graph

final def ==(arg0: Any): Boolean

def @id: String

lazy val @idIndex: Index

val @idStore: ValueStore[LTransaction.this.type]

lazy val @typeIndex: Index

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

def _indexEdge[S, E](edge: GEdge[S, E]): Unit

def _indexNode(node: GNode): Unit

def add: (structure.Graph) ⇒ structure.Graph

final def asInstanceOf[T0]: T0

implicit lazy val assistent: Assistent

def clone(): AnyRef

def close(): CancelableFuture[Unit]

def commit(): 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

val edgeStore: MemEdgeStore[LTransaction.this.type]

def edges: Edges

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def getOrCreateNode(id: Long): GNode

implicit lazy val guide: Guide[Observable]

lazy val hashCode: Int

lazy val idProvider: IdProvider

val index: MemIndexGraph

lazy val init: CancelableFuture[Unit]

val iri: String

final def isInstanceOf[T0]: Boolean

def isOpen: Boolean

def mergeNodes(nodes: Set[Node]): Task[Node]

def mergeValues[V](values: Set[Value[V]]): Task[Value[V]]

final def ne(arg0: AnyRef): Boolean

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

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

val newEdgeLock: AnyRef

def newNode(id: Long): GNode

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

val newValueLock: AnyRef

val nodeStore: MemNodeStore[LTransaction.this.type]

def nodes: Nodes

final def notify(): Unit

final def notifyAll(): Unit

lazy val ns: NameSpaceGraph

var open: Boolean

val parent: LGraph

def persist: CancelableFuture[Unit]

def resources: Resources

def rollback(): Unit

clears the transaction's MemGraph

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: LTransaction.this.type

def toFile(path: String, process: (Stream[Resource[_]], (String) ⇒ Unit) ⇒ String): Task[Unit]

def toString(): String

def transaction: Transaction

val valueStore: MemValueStore[LTransaction.this.type]

def values: Values

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wrapTR[T <: LGraph.GResource[_]](resource: T): _Resource[_]

def g(): librarian.traversal.Traversal[ClassType[Any], ClassType[Any], HNil]

lazy val traversal: librarian.traversal.Traversal[ClassType[Any], ClassType[Any], HNil]