EntityOid = string

Direction {...}{.pure.} = enum
  In, Out, OutIn

Edge = ref object
  oid*: EntityOid
  label*: string
  startsAt*: Node
  endsAt*: Node
  data: Table[string, Box]

Node = ref object
  oid*: EntityOid
  label*: string
  data: Table[string, Box]
  incoming: Table[EntityOid, Table[EntityOid, Edge]]
  outgoing: Table[EntityOid, Table[EntityOid, Edge]]

proc len[T: Node | Edge](entity: T): int

proc `$`(n: Node): string {...}{.raises: [ValueError], tags: [].}

proc `$`(e: Edge): string {...}{.raises: [ValueError], tags: [].}

proc describe(e: Edge; lineWidth: int = 100; propertyWidth: int = 20): string {...}{.
    raises: [ValueError], tags: [].}

proc describe(n: Node; lineWidth: int = 100; propertyWidth: int = 20): string {...}{.
    raises: [ValueError], tags: [].}

proc toMap[T: Node | Edge](entity: T): Map

proc newNode(label: string; data: Table[string, Box] = initTable();
             oid: string = $genOid()): Node {...}{.raises: [], tags: [].}

proc newEdge(A: Node; B: Node; label: string;
             data: Table[string, Box] = initTable(); oid: string = $genOid()): Edge {...}{.
    raises: [], tags: [].}

proc delete(e: Edge) {...}{.raises: [KeyError], tags: [].}

proc `==`(self, other: Node): bool {...}{.raises: [], tags: [].}

proc `==`(self, other: Edge): bool {...}{.raises: [], tags: [].}

proc `[]`(node: Node; property: string): Box {...}{.raises: [KeyError], tags: [].}

proc `[]=`(node: Node; property: string; value: Box) {...}{.raises: [], tags: [].}

proc `[]`(edge: Edge; property: string): Box {...}{.raises: [KeyError], tags: [].}

proc `[]=`(edge: Edge; property: string; value: Box) {...}{.raises: [], tags: [].}

proc numberOfNeighbors(n: Node; direction: Direction = Direction.Out): int {...}{.
    raises: [KeyError], tags: [].}

proc update[T](self: T; p: Table[string, Box]): string

proc neighbors(n: Node; direction: Direction = Direction.Out): (
    iterator (): string) {...}{.raises: [KeyError], tags: [].}

proc edges(n: Node; direction: Direction = Direction.Out): (iterator (): Edge) {...}{.
    raises: [KeyError], tags: [].}

proc between(A, B: Node; direction: Direction = Direction.Out): (
    iterator (): Edge) {...}{.raises: [KeyError], tags: [].}

proc connected(A, B: Node; direction: Direction = Direction.Out): bool {...}{.
    raises: [KeyError], tags: [].}

iterator pairs[T: Node | Edge](obj: T): (string, Box) {...}{.closure.}

iterator keys[T: Node | Edge](obj: T): string {...}{.closure.}

iterator values[T: Node | Edge](obj: T): Box {...}{.closure.}

template `.`(map: Map; entry: untyped): untyped