diff --git a/docs/annotations/adjacency.md b/docs/annotations/adjacency.md
index ad087d6e7c0cb31cd4dc5893630589f415854066..f9972abec25b08ec0d61d4b83415b71be2c12d6e 100644
--- a/docs/annotations/adjacency.md
+++ b/docs/annotations/adjacency.md
@@ -1,15 +1,18 @@
-Valid on frames: Vertex
+Valid on frames: **Vertex**
 
 Allowed prefixes when operation is AUTO: `add`, `get`, `remove`, `set`
 
 Annotation arguments:
 
-`value` - The label assigned to the edge which connects the adjacent nodes.
+`label` - The label assigned to the edge which connects the adjacent nodes.
 
-`direction` - The direction for the edge which creates the adjacency. It can be assigned any of the values from @org.apache.tinkerpop.gremlin.structure.Direction@.
+`direction` - The direction for the edge which creates the adjacency. It can be assigned any of the values from
+              @org.apache.tinkerpop.gremlin.structure.Direction@.
 
-`operation` - The operation the method will perform. Must be one of the following: `GET`, `ADD`, `SET`, `REMOVE`, `AUTO`.
-Defaults to `AUTO`.
+`operation` - The operation the method will perform. Must be one of the following: `GET`, `ADD`, `SET`, `REMOVE`,
+              `AUTO`. Defaults to `AUTO`.
+
+example:
 
 ```java
 @Adjacency("foo")
@@ -27,9 +30,12 @@ Adds a node as an adjacency to the current node, and the returns the newly conne
 
 Valid return types: `VertexFrame`
 
-Creates a new vertex without any type information as well as an untyped edge to connect to it. The newly created VertexFrame is returned.
+Creates a new vertex without any type information as well as an untyped edge to connect to it. The newly created
+`VertexFrame` is returned.
 
-Since the returned `VertexFrame` is always untyped the return type must be either `VertexFrame` or `TVertex` specifically.
+!!! note
+    Since the returned `VertexFrame` is always untyped the return type must be either `VertexFrame` or `TVertex`
+    specifically.
 
 example:
 
@@ -48,18 +54,20 @@ VertexFrame addFoobar();
 
 Valid return types: `VertexFrame`
 
-Creates a new edge without any type information and connects it between this vertex the vertex specified as an argument to the method. The frame returned is the same as the frame given in the argument, it is only there for compatability with other add methods. This method can also have a `void` return type.
+Creates a new edge without any type information and connects it between this vertex the vertex specified as an argument
+to the method. The frame returned is the same as the frame given in the argument, it is only there for compatability
+with other add methods. This method can also have a `void` return type.
 
 examples:
 
 ```java
 @Adjacency("Foo")
-Bar addFoobar(Bar existingVertex);
+BarVertex addFoobar(BarVertex existingVertex);
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> E addFoobar(E existingVertex);
+<E extends BarVertex> E addFoobar(E existingVertex);
 ```
 
 ```java
@@ -69,7 +77,7 @@ Bar addFoobar(Bar existingVertex);
 
 ```java
 @Adjacency(value = "Foo", operation = Adjacency.Operation.ADD)
-Bar E includeFoobar(Bar existingVertex);
+BarVertex includeFoobar(BarVertex existingVertex);
 ```
 
 
@@ -77,18 +85,20 @@ Bar E includeFoobar(Bar existingVertex);
 
 Valid return types: `VertexFrame`
 
-Creates a new edge without any type information and connects it between this vertex and a newly created vertex. The newly created vertex will have a type, as well as be initiated, according to the details specified in the ClassInitializer argument. Java generics can, and should, be used to narrow the return type.
+Creates a new edge without any type information and connects it between this vertex and a newly created vertex. The
+newly created vertex will have a type, as well as be initiated, according to the details specified in the
+ClassInitializer argument. Java generics can, and should, be used to narrow the return type.
 
 example:
 
 ```java
 @Adjacency("Foo")
-Bar addFoobar(ClassInitializer<? extends Bar> vertexInitializer);
+BarVertex addFoobar(ClassInitializer<? extends BarVertex> vertexInitializer);
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> E addFoobar(ClassInitializer<? extends E> vertexInitializer);
+<E extends BarVertex> E addFoobar(ClassInitializer<? extends E> vertexInitializer);
 ```
 
 ```java
@@ -98,39 +108,42 @@ Bar addFoobar(ClassInitializer<? extends Bar> vertexInitializer);
 
 ```java
 @Adjacency(value = "Foo", operation = Adjacency.Operation.ADD)
-Bar includeFoobar(ClassInitializer<? extends Bar> vertexInitializer);
+BarVertex includeFoobar(ClassInitializer<? extends BarVertex> vertexInitializer);
 ```
 
 ### Signature: `(ClassInitializer, ClassInitializer)`
 
 Valid return types: `VertexFrame`
 
-Creates a new edge and connects this to a new vertex. The newly created vertex will have a type, as well as be initiated, according to the details specified in the first ClassInitializer argument. Similarly the newly created edge will hava type, and be initiated using, the second ClassInitializer argument. Java generics can, and should, be used to narrow the return type.
+Creates a new edge and connects this to a new vertex. The newly created vertex will have a type, as well as be
+initiated, according to the details specified in the first ClassInitializer argument. Similarly the newly created edge
+will hava a type, and be initiated, using the second ClassInitializer argument. Java generics can, and should, be used
+to narrow the return type.
 
 example:
 
 ```java
 @Adjacency("Foo")
-Bar addFoobar(ClassInitializer<? extends Bar> vertexInitializer,
-              ClassInitializer<?> edgeInitializer);
+BarVertex addFoobar(ClassInitializer<? extends BarVertex> vertexInitializer,
+                    ClassInitializer<? extends FooEdge> edgeInitializer);
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> E addFoobar(ClassInitializer<? extends E> vertexInitializer,
-                            ClassInitializer<?> edgeInitializer);
+<E extends BarVertex> E addFoobar(ClassInitializer<? extends E> vertexInitializer,
+                                  ClassInitializer<? extends FooEdge> edgeInitializer);
 ```
 
 ```java
 @Adjacency("Foo")
 <E extends VertexFrame> E addFoobar(ClassInitializer<? extends E> vertexInitializer,
-                                    ClassInitializer<?> edgeInitializer);
+                                    ClassInitializer<? extends FooEdge> edgeInitializer);
 ```
 
 ```java
 @Adjacency(value = "Foo", operation = Adjacency.Operation.ADD)
-Bar includeFoobar(ClassInitializer<? extends Bar> vertexInitializer,
-              ClassInitializer<?> edgeInitializer);
+BarVertex includeFoobar(ClassInitializer<? extends BarVertex> vertexInitializer,
+                        ClassInitializer<? extends FooEdge> edgeInitializer);
 ```
 
 ## GET Operation
@@ -142,22 +155,28 @@ Get's one or more adjacent vertex from the graph.
 
 ### Signature: `( )`
 
-Valid return types: `VertexFrame` or `Iterator` or `List` or `Set`
+Valid return types: `EdgeFrame` or `Iterator` or `List` or `Set`
 
-Retrieves one or more of the adjacent vertex. If the return type is a single Frame then only the first instance is returned. If the return type is an `Iterator` or `Iterable` then it will supply all matching vertex. When using an `Iterator` or `Iterable` it is encouraged, but not required, to use generics. The returned frames will always be instantiated as the type encoded in the graph if there is one.
+Retrieves one or more of the adjacent edges. If the return type is a single Frame then only the first instance is
+returned. If the return type is an `Iterator` or `Iterable` then it will supply all matching vertex. When using an
+`Iterator` or `Iterable` it is encouraged, but not required, to use generics. The returned frames will always be
+instantiated as the type encoded in the graph if there is one.
 
-**Note:** If a type is specified in the arguments is a superclass of the returned element then an exception will be thrown. Therefore the return type specifed should always by the same type, or a superclass, of the expected return type. VertexFrame is always a safe return type for this method.
+!!! note
+    If a type is encoded in the in the graph is a superclass of the returned element then an exception will be thrown.
+    Therefore the return type specifed should always by the same type, or a superclass, of the expected return type.
+    VertexFrame is always a safe return type for this method.
 
 example:
 
 ```java
 @Adjacency("Foo")
-Bar getFoobar();
+BarVertex getFoobar();
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> E getFoobar();
+<E extends BarVertex> E getFoobar();
 ```
 
 ```java
@@ -167,12 +186,12 @@ Bar getFoobar();
 
 ```java
 @Adjacency("Foo")
-Iterator<Bar> getFoobar();
+Iterator<BarVertex> getFoobar();
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> Iterator<E> getFoobar();
+<E extends BarVertex> Iterator<E> getFoobar();
 ```
 
 ```java
@@ -182,17 +201,17 @@ Iterator<Bar> getFoobar();
 
 ```java
 @Adjacency("Foo")
-List<Bar> getFoobar();
+List<BarVertex> getFoobar();
 ```
 
 ```java
 @Adjacency("Foo")
-Set<Bar> getFoobar();
+Set<BarVertex> getFoobar();
 ```
 
 ```java
 @Adjacency(value = "Foo", operation = Adjacency.Operation.GET)
-Bar obtainFoobar();
+BarVertex obtainFoobar();
 ```
 
 
@@ -200,20 +219,24 @@ Bar obtainFoobar();
 
 Valid return types: `VertexFrame` or `Iterator` or `List` or `Set`
 
-Retrieves one or more of the adjacent vertex. If the return type is a specific Frame, an `Object`, or a `VertexFrame` then only the first instance is returned. If the return type is an iterator then it will iterate over all matches vertex. When using an Iterator it is encouraged to use generics.
+Retrieves one or more of the adjacent vertex. If the return type is a single `VertexFrame` then only the first instance
+is returned. If the return type is an `Iterator` then it will iterate over all matching vertex. When using an Iterator
+it is encouraged to use generics.
 
-The Class argument of the method specifes a filter such that only vertex which are of a matching type, or a subtype, to that of the argument will be returned.
+!!! note
+    The Class argument of the method specifes a filter such that only vertex which are of a matching type, or a subtype,
+    to that of the argument will be returned.
 
 example:
 
 ```java
 @Adjacency("Foo")
-Bar getFoobar(Class<? extends Bar> filter);
+BarVertex getFoobar(Class<? extends BarVertex> filter);
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> E getFoobar(Class<? extends E> filter);
+<E extends BarVertex> E getFoobar(Class<? extends E> filter);
 ```
 
 ```java
@@ -223,12 +246,12 @@ Bar getFoobar(Class<? extends Bar> filter);
 
 ```java
 @Adjacency("Foo")
-Iterator<Bar> getFoobar(Class<? extends Bar> filter);
+Iterator<BarVertex> getFoobar(Class<? extends BarVertex> filter);
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> Iterator<E> getFoobar(Class<? extends E> filter);
+<E extends BarVertex> Iterator<E> getFoobar(Class<? extends E> filter);
 ```
 
 ```java
@@ -238,17 +261,17 @@ Iterator<Bar> getFoobar(Class<? extends Bar> filter);
 
 ```java
 @Adjacency("Foo")
-List<Bar> getFoobar(Class<? extends Bar> filter);
+List<BarVertex> getFoobar(Class<? extends BarVertex> filter);
 ```
 
 ```java
 @Adjacency("Foo")
-Set<Bar> getFoobar(Class<? extends Bar> filter);
+Set<BarVertex> getFoobar(Class<? extends BarVertex> filter);
 ```
 
 ```java
 @Adjacency(value = "Foo", operation = Adjacency.Operation.GET)
-Bar obtainFoobar(Class<? extends Bar> filter);
+BarVertex obtainFoobar(Class<? extends BarVertex> filter);
 ```
 
 
@@ -288,12 +311,12 @@ example:
 
 ```java
 @Adjacency("Foo")
-void removeFoobar(Bar vertex);
+void removeFoobar(BarVertex vertex);
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> void removeFoobar(E vertex);
+<E extends BarVertex> void removeFoobar(E vertex);
 ```
 
 ```java
@@ -303,7 +326,7 @@ void removeFoobar(Bar vertex);
 
 ```java
 @Adjacency(value = "Foo", operation = Adjacency.Operation.REMOVE)
-void removeFoobar(Bar vertex);
+void removeFoobar(BarVertex vertex);
 ```
 
 
@@ -328,39 +351,42 @@ example:
 
 ```java
 @Adjacency("Foo")
-void setFoobar(Bar vertex);
+void setFoobar(BarVertex vertex);
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> void setFoobar(E vertex);
+<E extends BarVertex> void setFoobar(E vertex);
 ```
 
 ```java
 @Adjacency(value = "Foo", operation = Adjacency.Operation.SET)
-void assignFoobar(Bar vertex);
+void assignFoobar(BarVertex vertex);
 ```
 
 ### Signature: `(Iterator)`
 
 Valid return types: `void`
 
-The argument for this method must be an `Iterator` which iterates over vertex Frames. It is suggested you specify a Generic Type for the Iterator for usability.
+The argument for this method must be an `Iterator` which iterates over vertex Frames. It is suggested you specify a
+Generic Type for the Iterator for usability.
 
-This method will iterate over all the vertex specified in the Iterator argument and create new edges to connect to it. The edges in the graph will not encode a type.
+This method will iterate over all the vertex specified in the Iterator argument and create new edges to connect to it.
+The edges in the graph will not encode a type.
 
-Any existing edges matching the specified label that do not connect to one of the `VertexFrame` provided by the iterator will be removed.
+Any existing edges matching the specified label that do not connect to one of the `VertexFrame` provided by the iterator
+will be removed.
 
 example:
 
 ```java
 @Adjacency("Foo")
-void setFoobar(Iterator<Bar> vertex);
+void setFoobar(Iterator<BaBarVertexr> vertex);
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> void setFoobar(Iterator<? extends E> vertex);
+<E extends BarVertex> void setFoobar(Iterator<? extends E> vertex);
 ```
 
 ```java
@@ -372,39 +398,42 @@ void setFoobar(Iterator<Bar> vertex);
 
 Valid return types: `void`
 
-The argument for this method must be an `Iterable` or a subclass of `Iterable` which iterates over vertex Frames. It is suggested you specify a Generic Type for the Iterator for usability.
+The argument for this method must be an `Iterable` or a subclass of `Iterable` which iterates over vertex Frames. It is
+suggested you specify a Generic Type for the Iterator for usability.
 
 Since all Java collections inherit from the `Iterable` interface they can also be used as parameters to these methods.
 
-This method will iterate over all the vertex specified in the `Iterable` argument and create new edges to connect to it. The edges in the graph will not encode a type.
+This method will iterate over all the vertex specified in the `Iterable` argument and create new edges to connect to it.
+The edges in the graph will not encode a type.
 
-Any existing edges matching the specified label that do not connect to one of the `VertexFrame` provided by the iterator will be removed.
+Any existing edges matching the specified label that do not connect to one of the `VertexFrame` provided by the iterator
+will be removed.
 
 example:
 
 ```java
 @Adjacency("Foo")
-void setFoobar(Iterable<Bar> vertex);
+void setFoobar(Iterable<BarVertex> vertex);
 ```
 
 ```java
 @Adjacency("Foo")
-void setFoobar(Collection<Bar> vertex);
+void setFoobar(Collection<BarVertex> vertex);
 ```
 
 ```java
 @Adjacency("Foo")
-void setFoobar(List<Bar> vertex);
+void setFoobar(List<BarVertex> vertex);
 ```
 
 ```java
 @Adjacency("Foo")
-void setFoobar(Set<Bar> vertex);
+void setFoobar(Set<BarVertex> vertex);
 ```
 
 ```java
 @Adjacency("Foo")
-<E extends Bar> void setFoobar(Iterable<? extends E> vertex);
+<E extends BarVertex> void setFoobar(Iterable<? extends E> vertex);
 ```
 
 ```java
diff --git a/docs/annotations/incidence.md b/docs/annotations/incidence.md
new file mode 100644
index 0000000000000000000000000000000000000000..84b48b438a985014a15bcd6010ee48774823c16e
--- /dev/null
+++ b/docs/annotations/incidence.md
@@ -0,0 +1,344 @@
+Valid on frames: **Vertex**
+
+Allowed prefixes when operation is AUTO: `add`, `get`, `remove`
+
+Annotation arguments:
+
+`label` - The label assigned to the edge which connects the adjacent nodes.
+
+`direction` - The direction for the edge which creates the adjacency. It can be assigned any of the values from
+              @org.apache.tinkerpop.gremlin.structure.Direction@.
+
+`operation` - The operation the method will perform. Must be one of the following: `GET`, `ADD`, `SET`, `REMOVE`,
+              `AUTO`. Defaults to `AUTO`.
+
+example:
+
+```java
+@Incidence("foo")
+//Method declared here
+```
+
+## ADD Operation
+
+Valid method signatures: `( )`, `(VertexFrame)`, `(ClassInitializer)`, `(VertexFrame, ClassInitializer)`,
+`(ClassInitializer, ClassInitializer)`
+
+Adds an edge to edge to a node and returns the new `EdgeFrame`.
+
+### Signature: `( )`
+
+Valid return types: `EdgeFrame`
+
+Creates a new vertex without any type information as well as an untyped edge to connect to it. The newly created
+`TEdge` is returned.
+
+!!! note
+    Since the returned `VertexFrame` is always untyped the return type must be either `VertexFrame` or `TVertex`
+    specifically.
+
+```java
+@Incidence("Foo")
+EdgeFrame addFoobar();
+```
+
+```java
+@Incidence(value = "Foo", operation = Adjacency.Operation.ADD)
+TEdge addFoobar();
+```
+
+### Signature: `(VertexFrame)`
+
+Valid return types: `EdgeFrame`
+
+Creates a new edge without any type information and connects it between this vertex the vertex specified as an argument
+to the method. The frame returned is the newly created `TEdge`.
+
+examples:
+
+```java
+@Incidence("Foo")
+FooEdge addFoobar(BarVertex existingVertex);
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> E addFoobar(BarVertex existingVertex);
+```
+
+```java
+@Incidence("Foo")
+EdgeFrame addFoobar(BarVertex existingVertex);
+```
+
+```java
+@Incidence("Foo")
+<E extends EdgeFrame> E addFoobar(BarVertex existingVertex);
+```
+
+```java
+@Incidence(value = "Foo", operation = Adjacency.Operation.ADD)
+FooEdge includeFoobar(BarVertex existingVertex);
+```
+
+### Signature: `(ClassInitializer)`
+
+Valid return types: `EdgeFrame`
+
+Creates a new edge without any type information and connects it between this vertex and a newly created vertex. The
+newly created vertex will have a type, as well as be initiated, according to the details specified in the
+ClassInitializer argument. Java generics can, and should, be used to narrow the return type. The returned object will be
+the newly created `TEdge`.
+
+example:
+
+```java
+@Incidence("Foo")
+FooEdge addFoobar(ClassInitializer<? extends FooEdge> vertexInitializer);
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> E addFoobar(ClassInitializer<? extends BarVertex> vertexInitializer);
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> E addFoobar(ClassInitializer<? extends BarVertex> vertexInitializer);
+```
+
+```java
+@Incidence(value = "Foo", operation = Adjacency.Operation.ADD)
+TEdge includeFoobar(ClassInitializer<? extends BarVertex> vertexInitializer);
+```
+
+### Signature: `(VertexFrame, ClassInitializer)`
+
+Valid return types: `EdgeFrame`
+
+Creates a new edge and connects this to an existing vertex. The newly created edge will have a type, as well as be
+initiated, according to the details specified in the ClassInitializer argument. Java generics can, and should, be used
+to narrow the return type. The returned object will be the newly created `EdgeFrame`.
+
+example:
+
+```java
+@Incidence("Foo")
+FooEdge addFoobar(BarVertex bar,
+                  ClassInitializer<? extends FooEdge> edgeInitializer);
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> E addFoobar(BarVertex bar,
+                                ClassInitializer<? extends E> edgeInitializer);
+```
+
+```java
+@Incidence("Foo")
+<E extends EdgeFrame> E addFoobar(VertexFrame vertex,
+                                  ClassInitializer<? extends E> edgeInitializer);
+```
+
+```java
+@Incidence(value = "Foo", operation = Adjacency.Operation.ADD)
+FooEdge includeFoobar(BarVertex bar,
+                      ClassInitializer<? extends FooEdge> edgeInitializer);
+```
+
+### Signature: `(ClassInitializer, ClassInitializer)`
+
+Valid return types: `EdgeFrame`
+
+Creates a new edge and connects this to a new vertex. The newly created vertex will have a type, as well as be
+initiated, according to the details specified in the first ClassInitializer argument. Similarly the newly created edge
+will hava a type, and be initiated, using the second ClassInitializer argument. Java generics can, and should, be used
+to narrow the return type. The returned object will be the newly created `EdgeFrame`.
+
+example:
+
+```java
+@Incidence("Foo")
+FooEdge addFoobar(ClassInitializer<? extends BarVertex> vertexInitializer,
+                    ClassInitializer<? extends FooEdge> edgeInitializer);
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> E addFoobar(ClassInitializer<? extends BarVertex> vertexInitializer,
+                                  ClassInitializer<? extends E> edgeInitializer);
+```
+
+```java
+@Incidence("Foo")
+<E extends EdgeFrame> E addFoobar(ClassInitializer<? extends BarVertex> vertexInitializer,
+                                  ClassInitializer<? extends E> edgeInitializer);
+```
+
+```java
+@Incidence(value = "Foo", operation = Adjacency.Operation.ADD)
+FooEdge includeFoobar(ClassInitializer<? extends BarVertex> vertexInitializer,
+                      ClassInitializer<? extends FooEdge> edgeInitializer);
+```
+
+## GET Operation
+
+Valid method signatures: `()`, `(Class)`
+
+Get's one or more adjacent edgesd from the graph.
+
+
+### Signature: `( )`
+
+Valid return types: `VertexFrame` or `Iterator` or `List` or `Set`
+
+Retrieves one or more of the adjacent vertex. If the return type is a single Frame then only the first instance is
+returned. If the return type is an `Iterator` or `List` or `Set` then it will supply all matching edges. When using an
+`Iterator` or `List` or `Set` it is encouraged, but not required, to use generics. The returned frames will always be
+instantiated as the type encoded in the graph if there is one.
+
+!!! note
+    If a type is encoded in the in the graph is a superclass of the returned element then an exception will be thrown.
+    Therefore the return type specifed should always by the same type, or a superclass, of the expected return type.
+    VertexFrame is always a safe return type for this method.
+
+example:
+
+```java
+@Incidence("Foo")
+FooEdge getFoobar();
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> E getFoobar();
+```
+
+```java
+@Incidence("Foo")
+<E extends EdgeFrame> E getFoobar();
+```
+
+```java
+@Incidence("Foo")
+Iterator<FooEdge> getFoobar();
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> Iterator<E> getFoobar();
+```
+
+```java
+@Incidence("Foo")
+<E extends EdgeFrame> Iterator<E> getFoobar();
+```
+
+```java
+@Incidence("Foo")
+List<FooEdge> getFoobar();
+```
+
+```java
+@Incidence("Foo")
+Set<FooEdge> getFoobar();
+```
+
+```java
+@Incidence(value = "Foo", operation = Adjacency.Operation.GET)
+FooEdge obtainFoobar();
+```
+
+
+### Signature: `(Class)`
+
+Valid return types: `VertexFrame` or `Iterator` or `List` or `Set`
+
+Retrieves one or more of the adjacent edges. If the return type is a single `EdgeFrame` then only the first instance
+is returned. If the return type is an `Iterator` then it will iterate over all matching vertex. When using an Iterator
+it is encouraged to use generics.
+
+!!! note
+    The Class argument of the method specifes a filter such that only vertex which are of a matching type, or a subtype,
+    to that of the argument will be returned.
+
+example:
+
+```java
+@Incidence("Foo")
+FooEdge getFoobar(Class<? extends FooEdge> filter);
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> E getFoobar(Class<? extends E> filter);
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> E getFoobar(Class<? extends E> filter);
+```
+
+```java
+@Incidence("Foo")
+Iterator<FooEdge> getFoobar(Class<? extends FooEdge> filter);
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> Iterator<E> getFoobar(Class<? extends E> filter);
+```
+
+```java
+@Incidence("Foo")
+<E extends EdgeFrame> Iterator<E> getFoobar(Class<? extends E> filter);
+```
+
+```java
+@Incidence("Foo")
+List<FooEdge> getFoobar(Class<? extends FooEdge> filter);
+```
+
+```java
+@Incidence("Foo")
+Set<FooEdge> getFoobar(Class<? extends FooEdge> filter);
+```
+
+```java
+@Incidence(value = "Foo", operation = Adjacency.Operation.GET)
+FooEdge obtainFoobar(Class<? extends FooEdge> filter);
+```
+
+## REMOVE Operation
+
+Valid method signatures: `(EdgeFrame)`
+
+Removes an edges which cause an adjacency, leaving the vertex in place.
+
+### Signature: `(EdgeFrame)`
+
+Valid return types: `void`
+
+Removes the edge specified in the argument. This is entirely equivelant to just calling the `remove()` method on the
+`EdgeFrame`
+
+example:
+
+```java
+@Incidence("Foo")
+void removeFoobar(FooEdge edge);
+```
+
+```java
+@Incidence("Foo")
+<E extends FooEdge> void removeFoobar(E edge);
+```
+
+```java
+@Incidence("Foo")
+<E extends EdgeFrame> void removeFoobar(E edge);
+```
+
+```java
+@Incidence(value = "Foo", operation = Adjacency.Operation.REMOVE)
+void removeFoobar(FooEdge edge);
diff --git a/docs/annotations/overview.md b/docs/annotations/overview.md
index ddb5d6a59d6acd40ba919b6f1ebc1691877d8f13..aa71400e81c8bff8857d9f6572d65267cf08ab9b 100644
--- a/docs/annotations/overview.md
+++ b/docs/annotations/overview.md
@@ -1,7 +1,15 @@
-The Ferma schema is defined by a collection of interfaces and classes written by the user. Each method will interact with the underlying graph to either modify the graph in some way, or to retrieve an element or property from the graph. There are two techniques for defining how these methods behave. Either you can explicitly implement the method, or you can leave the method as abstract and annotate the method in order to allow Ferma to implement the method for you. Here we will define the annotations available to you and how they work, along with a few examples.
+The Ferma schema is defined by a collection of interfaces and classes written by the user. Each method will interact
+with the underlying graph to either modify the graph in some way, or to retrieve an element or property from the graph.
+There are two techniques for defining how these methods behave. Either you can explicitly implement the method, or you
+can leave the method as abstract and annotate the method in order to allow Ferma to implement the method for you. Here
+we will define the annotations available to you and how they work, along with a few examples.
 
-The behavior of an annotated method is dictated not only by the annotation applied to it but also the method's signature. Therefore an annotated method will behave differently if it's return type, arguments, or even if the method name were to change. It is important to note that when a method is explicitly defined (doesnt use an annotation) then the method signature can be anything.
+The behavior of an annotated method is dictated not only by the annotation applied to it but also the method's
+signature. Therefore an annotated method will behave differently if it's return type, arguments, or even if the method
+name were to change. It is important to note that when a method is explicitly defined (doesnt use an annotation) then
+the method signature can be anything.
 
 Method names that are annotated must have one of the following prefixes: add, get, remove, set, is, can.
 
-Below specifies that annotations that can be used when defining a Frame's interface. By specifying the method argument and return types, the underlying graph is constrained to the interface specification.
+Below specifies that annotations that can be used when defining a Frame's interface. By specifying the method argument
+and return types, the underlying graph is constrained to the interface specification.
diff --git a/docs/annotations/property.md b/docs/annotations/property.md
index c09733c7d1ce2e8e1d97f18821407e12bd514d5e..941fd2dde27e8eeecfe13745e6be4c606bea0c5d 100644
--- a/docs/annotations/property.md
+++ b/docs/annotations/property.md
@@ -1,4 +1,4 @@
-Valid on frames: Edge and Vertex
+Valid on frames: **Edge** and **Vertex**
 
 Allowed prefixes when operation is AUTO: `get`, `is`, `can`, `set`, `remove`
 
@@ -11,6 +11,8 @@ Defaults to `AUTO`.
 
 The following would bind the method it is used on to the property named `foo`:
 
+example:
+
 ```java
 @Property("foo")
 //Method declared here
@@ -24,7 +26,7 @@ Valid method signatures: `( )`
 
 ### Signature: `( )`
 
-Valid return types: *Any Object*
+Valid return types: `Object` or any primitive.
 
 Get the property value of an element. Used when property is not a boolean value.
 
diff --git a/docs/comparing_the_alternatives.md b/docs/comparing_the_alternatives.md
index 8dabb3c7f45ce6a1f640e2501a89b0dcc03e9ca1..51705707b4762472ed193bd82fddc772d6ec281e 100644
--- a/docs/comparing_the_alternatives.md
+++ b/docs/comparing_the_alternatives.md
@@ -1,8 +1,14 @@
-There are several OGM/ORM options out there. For the purposes of this document we will focus only on those that have a stable release, or are close to a stable release. At the time of this writing those are: Tinkerpop Framed and Totorom.
+There are several OGM/ORM options out there. For the purposes of this document we will focus only on those that have a
+stable release, or are close to a stable release. At the time of this writing those are: Tinkerpop Framed and Totorom.
 
 ## Benchmarks
 
-We maintain an informal project for benchmarking Ferma against other OGM available, you can find the [source here](https://github.com/Syncleus/Ferma-benchmark). However below is a matrix breakdown of the results. Instead of showing raw execution time we show the ratio of each OGM compared to Ferma. Therefore if the table lists 1x then it means the framework has the same execution time as Ferma, if it lists 2x then it took twice as long to execute, and if it indicates 0.5x then it took half the time to execute. Obviously any value less than 1x indicates the OGM out performed Ferma and any value greater than 1x indicates Ferma had the superior performance tiimes.
+We maintain an informal project for benchmarking Ferma against other OGM available, you can find the
+[source here](https://github.com/Syncleus/Ferma-benchmark). However below is a matrix breakdown of the results. Instead
+of showing raw execution time we show the ratio of each OGM compared to Ferma. Therefore if the table lists 1x then it
+means the framework has the same execution time as Ferma, if it lists 2x then it took twice as long to execute, and if
+it indicates 0.5x then it took half the time to execute. Obviously any value less than 1x indicates the OGM out
+performed Ferma and any value greater than 1x indicates Ferma had the superior performance tiimes.
 
 |                                           | **Blueprints** | **Gremlin Pipeline** | **Tinkerpop3** | **Frames**  | **Totorom** | **Peapod**  |
 |-------------------------------------------|----------------|----------------------|----------------|-------------|-------------|-------------|
@@ -12,11 +18,16 @@ We maintain an informal project for benchmarking Ferma against other OGM availab
 | **Get verticies and call next (untyped)** | x0.79          | x3.87                | x11.74         | Not capable | x4.81       | Not capable |
 | **Get verticies and call next (typed)**   | x0.72          | x2.91                | Not capable    | x1.94       | x3.31       | x16.70      |
 
-As can be seen Ferma out performs all the alternative solutions considerably by several orders of magnitude. While results do vary slightly from system to system these results are pretty close to typical. Go ahead, check out the benchmark program and run it for yourself!
+As can be seen Ferma out performs all the alternative solutions considerably by several orders of magnitude. While
+results do vary slightly from system to system these results are pretty close to typical. Go ahead, check out the
+benchmark program and run it for yourself!
 
 ## Feature Breakdown
 
-Despite the superior performance of Ferma it also supports all the features provided by the alternatives out there, not to mention several novel features. The following gives a quick breakdown of the features of the various frameworks. We also include a bit later in the document some Ferma examples showing the various features in action. All of the examples below use the domain model [found here](Ferma:Domain_Example).
+Despite the superior performance of Ferma it also supports all the features provided by the alternatives out there, not
+to mention several novel features. The following gives a quick breakdown of the features of the various frameworks. We
+also include a bit later in the document some Ferma examples showing the various features in action. All of the examples
+below use the domain model [found here](Ferma:Domain_Example).
 
 |                                                                                                                  | **Ferma**     | **Frames**    | **Totorom**   | **Peapod**    |
 |------------------------------------------------------------------------------------------------------------------|---------------|---------------|---------------|---------------|
@@ -30,7 +41,8 @@ Despite the superior performance of Ferma it also supports all the features prov
 | **Tinkerpop 2 support**                                                                                          | Supported     | Supported     | Supported     | Not Supported |
 | **Tinkerpop 3 support**                                                                                          | Not Supported | Not Supported | Not Supported | Supported     |
 
-\* While Peapod does support querying for all instances of a type, and its subtypes, it does not support a mechanism to query for a specific type while excluding subtypes.
+\* While Peapod does support querying for all instances of a type, and its subtypes, it does not support a mechanism to
+query for a specific type while excluding subtypes.
 
 ### Type information encoded into graph
 
diff --git a/docs/getting_started.md b/docs/getting_started.md
index 6116561a7924f645f6d84e70ffa910a12c478d5f..4d01cb0679ca47be9660cb841932520333148a2d 100644
--- a/docs/getting_started.md
+++ b/docs/getting_started.md
@@ -1,4 +1,8 @@
-Ferma provides three levels of type resolution: untyped, simple, and annotated. In untyped mode Ferma doesn't handle typing at all, instead the type must be explicitly indicated whenever querying. In simple mode Ferma provides type context encoded as graph element properties which ensures the same type comes out that goes in to a graph. In annotated mode all the features of simple mode are provided as well as enabling the use of annotations on abstract methods to instruct Ferma to dynamically construct byte code to implement the abstract methods at start up.
+Ferma provides three levels of type resolution: untyped, simple, and annotated. In untyped mode Ferma doesn't handle
+typing at all, instead the type must be explicitly indicated whenever querying. In simple mode Ferma provides type
+context encoded as graph element properties which ensures the same type comes out that goes in to a graph. In annotated
+mode all the features of simple mode are provided as well as enabling the use of annotations on abstract methods to
+instruct Ferma to dynamically construct byte code to implement the abstract methods at start up.
 
 ## Dependency
 
@@ -14,7 +18,8 @@ To include Ferma in your project of choice include the following Maven dependenc
 
 ## Untyped Mode Example
 
-In untyped mode there is no automatic typing. Whatever class is explicitly indicated is the type that will be instantiated when performing queries. Lets start with a simple example domain.
+In untyped mode there is no automatic typing. Whatever class is explicitly indicated is the type that will be
+instantiated when performing queries. Lets start with a simple example domain.
 
 ```java
 public class Person extends VertexFrame {
@@ -72,7 +77,10 @@ public void testUntyped() {
 
 ## Simple Mode Example
 
-In simple mode you must provide concrete classes, no abstract or interfaces allowed, and the class should always extend from a FramedVertex or FramedEdge. Simple mode doesn't provide any annotations either. The purpose of simple mode is to provide type resolution. Basically the type of object you use when adding to the graph is the same type you get out when reading from the graph.
+In simple mode you must provide concrete classes, no abstract or interfaces allowed, and the class should always extend
+from a FramedVertex or FramedEdge. Simple mode doesn't provide any annotations either. The purpose of simple mode is to
+provide type resolution. Basically the type of object you use when adding to the graph is the same type you get out when
+reading from the graph.
 
 Say we extend the Person class with the Programmer class.
 
@@ -106,7 +114,11 @@ public void testSimpleTyping() {
 
 ## Annotated Mode Example
 
-In annotated mode you can either provide concrete classes, abstract classes, or even interfaces. Abstract classes and concrete classes must extend from FramedVertex or FramedEdge, however, interfaces do not have this restriction. Annotated mode also provides a set of annotations which must be used to define any abstract methods that are to be implemented by the engine. Annotated mode provides the same type resolution as provided by simple mode with a bit more power to determine parent-child relationships at run time.
+In annotated mode you can either provide concrete classes, abstract classes, or even interfaces. Abstract classes and
+concrete classes must extend from FramedVertex or FramedEdge, however, interfaces do not have this restriction.
+Annotated mode also provides a set of annotations which must be used to define any abstract methods that are to be
+implemented by the engine. Annotated mode provides the same type resolution as provided by simple mode with a bit more
+power to determine parent-child relationships at run time.
 
 The same example as above done with annotations would look something like this.
 
@@ -150,7 +162,9 @@ public abstract class Programmer extends Person {
 }
 ```
 
-If we pass a collection of Class objects to the FramedGraph constructor then the annotated type resolver will be used. In this mode you want to tell the engine what classes you will be using so it can handle type resolution properly and construct the byte code for any abstract annotated methods.
+If we pass a collection of Class objects to the FramedGraph constructor then the annotated type resolver will be used.
+In this mode you want to tell the engine what classes you will be using so it can handle type resolution properly and
+construct the byte code for any abstract annotated methods.
 
 ```java
 public void testAnnotatedTyping() {
diff --git a/docs/glossary.md b/docs/glossary.md
index a6c332b1f4e17a817762f2b0a5f4e2f7cb10b8ed..bad9b0689f9c9f077cc384af0666791cf6f00813 100644
--- a/docs/glossary.md
+++ b/docs/glossary.md
@@ -1,3 +1,4 @@
-**Frame** - A class from the schema that represents an element from the graph. A frame usually extends either a VertexFrame or an EdgeFrame, though they are not required to do so.
+**Frame** - A class from the schema that represents an element from the graph. A frame usually extends either a
+            VertexFrame or an EdgeFrame, though they are not required to do so.
 
 **Element** - Either a vertex or an edge in a graph.
diff --git a/docs/index.md b/docs/index.md
index 3fad35730924f8bb7ac2a81546a7967290dcf5a3..3d216efd870c562dab09de345dddb066bdf68e11 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -57,8 +57,7 @@ including the following.
 -   [Neo4j](http://neo4j.com)
 -   [OrientDB](http://www.orientechnologies.com/orientdb/)
 -   [MongoDB](http://www.mongodb.org)
--   [Oracle
-    NoSQL](http://www.oracle.com/us/products/database/nosql/overview/index.html)
+-   [Oracle NoSQL](http://www.oracle.com/us/products/database/nosql/overview/index.html)
 -   TinkerGraph
 
 Ferma Javadocs:
@@ -84,8 +83,7 @@ Ferma Javadocs:
 
 For support please use
 [Gitter](https://gitter.im/Syncleus/Ferma?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-or the [official Ferma mailing
-list](https://groups.google.com/a/syncleus.com/forum/#!forum/ferma-list).
+or the [official Ferma mailing list](https://groups.google.com/a/syncleus.com/forum/#!forum/ferma-list).
 
 Please file bugs and feature requests on
 [Github](https://github.com/Syncleus/Ferma/issues).
diff --git a/mkdocs.yml b/mkdocs.yml
index 48b2f83675969cfb1a61a4e89f11cbc64cdab379..882c2633563f339a8c919e81664c9079c7e071e8 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -1,16 +1,22 @@
 site_name: Ferma
 theme: material
-repo_name: 'GitHub'
+repo_name: 'Syncleus/Ferma'
 repo_url: 'https://github.com/Syncleus/Ferma'
 site_dir: 'target/mkdocs'
+edit_uri: 'edit/master/docs'
+site_description: 'An ORM / OGM for the TinkerPop graph stack.'
+site_author: 'Syncleus'
+copyright: 'Copyright &copy; 2004 - 2017 Syncleus, Inc.'
+site_url: 'http://syncleus.com/Ferma'
 pages:
     - Home: index.md
     - Getting Started: getting_started.md
     - Comparing the Alternatives: comparing_the_alternatives.md
     - Core Annotations:
         - Overview: annotations/overview.md
+        - '@Adjacency': annotations/adjacency.md
+        - '@Incidence': annotations/incidence.md
         - '@Property': annotations/property.md
-        - '@adjacency': annotations/adjacency.md
     - Glossary: glossary.md
 extra:
   version: '3.2.0'
@@ -22,9 +28,26 @@ extra:
     accent: 'deep orange'
   author:
     github: 'Syncleus'
+  social:
+    - type: 'github'
+      link: 'https://github.com/Syncleus'
+  disqus: 'syncleus'
 
 markdown_extensions:
-  - codehilite(css_class=code)
+  - codehilite
   - admonition
-  - toc:
-      permalink: '#'
+  - toc(permalink=true)
+  - pymdownx.arithmatex
+  - pymdownx.betterem(smart_enable=all)
+  - pymdownx.caret
+  - pymdownx.critic
+  - pymdownx.details
+  - pymdownx.emoji:
+      emoji_generator: !!python/name:pymdownx.emoji.to_svg
+  - pymdownx.inlinehilite
+  - pymdownx.magiclink
+  - pymdownx.mark
+  - pymdownx.smartsymbols
+  - pymdownx.superfences
+  - pymdownx.tasklist(custom_checkbox=true)
+  - pymdownx.tilde