## Uses of Interface
org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal

- Packages that use GraphTraversal
  Package | Description
  --- | ---
  org.apache.tinkerpop.gremlin |
  org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential |
  org.apache.tinkerpop.gremlin.neo4j.structure |
  org.apache.tinkerpop.gremlin.process.traversal |
  org.apache.tinkerpop.gremlin.process.traversal.dsl.graph |

- - ### Uses of GraphTraversal in org.apache.tinkerpop.gremlin

    Methods in org.apache.tinkerpop.gremlin that return GraphTraversal
    Modifier and Type | Method and Description
    --- | ---
    `GraphTraversal<Vertex,VertexProperty<Object>>` | AbstractGremlinTest.`convertToVertexProperty(Graph graph, String vertexName, String vertexPropertyKey)`
    `GraphTraversal<Vertex,Object>` | AbstractGremlinTest.`convertToVertexPropertyId(Graph graph, String vertexName, String vertexPropertyKey)`
    `GraphTraversal<Vertex,Object>` | AbstractGremlinTest.`convertToVertexPropertyId(String vertexName, String vertexPropertyKey)`

  - ### Uses of GraphTraversal in org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential

    Subinterfaces of GraphTraversal in org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `CredentialTraversalDsl<S,E>` A DSL for managing a "credentials graph" used by Gremlin Server for simple authentication functions.

    Methods in org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential that return GraphTraversal
    Modifier and Type | Method and Description
    --- | ---
    `default GraphTraversal<S,Vertex>` | CredentialTraversalDsl.`user(String username, String password)` Creates or updates a user.
    `GraphTraversal<Vertex,Vertex>` | CredentialTraversalSourceDsl.`user(String username, String password)` Creates or updates a user.
    `default GraphTraversal<S,Vertex>` | CredentialTraversalDsl.`users()` Finds all users.
    `GraphTraversal<Vertex,Vertex>` | CredentialTraversalSourceDsl.`users()` Finds all users.
    `default GraphTraversal<S,Vertex>` | CredentialTraversalDsl.`users(String username, String... more)` Finds users by name.
    `GraphTraversal<Vertex,Vertex>` | CredentialTraversalSourceDsl.`users(String username, String... more)` Finds users by name.

  - ### Uses of GraphTraversal in org.apache.tinkerpop.gremlin.neo4j.structure

    Methods in org.apache.tinkerpop.gremlin.neo4j.structure that return GraphTraversal
    Modifier and Type | Method and Description
    --- | ---
    `<S,E> GraphTraversal<S,E>` | Neo4jGraph.`cypher(String query)` Execute the Cypher query and get the result set as a `GraphTraversal`.
    `<S,E> GraphTraversal<S,E>` | Neo4jGraph.`cypher(String query, Map<String,Object> parameters)` Execute the Cypher query with provided parameters and get the result set as a `GraphTraversal`.

  - ### Uses of GraphTraversal in org.apache.tinkerpop.gremlin.process.traversal

    Fields in org.apache.tinkerpop.gremlin.process.traversal with type parameters of type GraphTraversal
    Modifier and Type | Field and Description
    --- | ---
    `UnaryOperator<GraphTraversal<?,?>>` | TraversalInterruptionTest.`traversalAfterPause`
    `Function<GraphTraversalSource,GraphTraversal<?,?>>` | TraversalInterruptionTest.`traversalBeforePause`
    `Function<GraphTraversalSource,GraphTraversal<?,?>>` | TraversalInterruptionComputerTest.`traversalMaker`

  - ### Uses of GraphTraversal in org.apache.tinkerpop.gremlin.process.traversal.dsl.graph

    Subinterfaces of GraphTraversal in org.apache.tinkerpop.gremlin.process.traversal.dsl.graph
    Modifier and Type | Interface and Description
    --- | ---
    `static interface` | `GraphTraversal.Admin<S,E>`

    Classes in org.apache.tinkerpop.gremlin.process.traversal.dsl.graph that implement GraphTraversal
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultGraphTraversal<S,E>`

    Methods in org.apache.tinkerpop.gremlin.process.traversal.dsl.graph that return GraphTraversal
    Modifier and Type | Method and Description
    --- | ---
    `static <A> GraphTraversal<A,A>` | __.`__(A... starts)`
    `default GraphTraversal<S,Edge>` | GraphTraversal.`addE(String edgeLabel)` Adds an `Edge` with the specified edge label.
    `GraphTraversal<Edge,Edge>` | GraphTraversalSource.`addE(String label)` Spawns a `GraphTraversal` by adding a edge with the specified label.
    `static <A> GraphTraversal<A,Edge>` | __.`addE(String edgeLabel)`
    `default GraphTraversal<S,Edge>` | GraphTraversal.`addE(Traversal<?,String> edgeLabelTraversal)` Adds a `Edge` with an edge label determined by a `Traversal`.
    `GraphTraversal<Edge,Edge>` | GraphTraversalSource.`addE(Traversal<?,String> edgeLabelTraversal)` Spawns a `GraphTraversal` by adding a edge with a label as specified by the provided `Traversal`.
    `static <A> GraphTraversal<A,Edge>` | __.`addE(Traversal<?,String> edgeLabelTraversal)`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`addV()` Adds a `Vertex` with a default vertex label.
    `GraphTraversal<Vertex,Vertex>` | GraphTraversalSource.`addV()` Spawns a `GraphTraversal` by adding a vertex with the default label.
    `static <A> GraphTraversal<A,Vertex>` | __.`addV()`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`addV(String vertexLabel)` Adds a `Vertex`.
    `GraphTraversal<Vertex,Vertex>` | GraphTraversalSource.`addV(String label)` Spawns a `GraphTraversal` by adding a vertex with the specified label.
    `static <A> GraphTraversal<A,Vertex>` | __.`addV(String vertexLabel)`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`addV(Traversal<?,String> vertexLabelTraversal)` Adds a `Vertex` with a vertex label determined by a `Traversal`.
    `GraphTraversal<Vertex,Vertex>` | GraphTraversalSource.`addV(Traversal<?,String> vertexLabelTraversal)` Spawns a `GraphTraversal` by adding a vertex with the label as determined by a `Traversal`.
    `static <A> GraphTraversal<A,Vertex>` | __.`addV(Traversal<?,String> vertexLabelTraversal)`
    `default GraphTraversal<S,E>` | GraphTraversal.`aggregate(Scope scope, String sideEffectKey)` Collects objects in a list using the `Scope` argument to determine whether it should be lazy `Scope.local` or eager (`Scope.global` while gathering those objects.
    `static <A> GraphTraversal<A,A>` | __.`aggregate(Scope scope, String sideEffectKey)`
    `default GraphTraversal<S,E>` | GraphTraversal.`aggregate(String sideEffectKey)` Eagerly collects objects up to this step into a side-effect.
    `static <A> GraphTraversal<A,A>` | __.`aggregate(String sideEffectKey)`
    `default GraphTraversal<S,E>` | GraphTraversal.`and(Traversal<?,?>... andTraversals)` Ensures that all of the provided traversals yield a result.
    `static <A> GraphTraversal<A,A>` | __.`and(Traversal<?,?>... andTraversals)`
    `default GraphTraversal<S,E>` | GraphTraversal.`as(String stepLabel, String... stepLabels)` A step modulator that provides a label to the step that can be accessed later in the traversal by other steps.
    `static <A> GraphTraversal<A,A>` | __.`as(String label, String... labels)`
    `default GraphTraversal<S,E>` | GraphTraversal.`barrier()` Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
    `static <A> GraphTraversal<A,A>` | __.`barrier()`
    `default GraphTraversal<S,E>` | GraphTraversal.`barrier(Consumer<TraverserSet<Object>> barrierConsumer)` Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
    `static <A> GraphTraversal<A,A>` | __.`barrier(Consumer<TraverserSet<Object>> barrierConsumer)`
    `default GraphTraversal<S,E>` | GraphTraversal.`barrier(int maxBarrierSize)` Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
    `static <A> GraphTraversal<A,A>` | __.`barrier(int maxBarrierSize)`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`both(String... edgeLabels)` Map the `Vertex` to its adjacent vertices given the edge labels.
    `static GraphTraversal<Vertex,Vertex>` | __.`both(String... edgeLabels)`
    `default GraphTraversal<S,Edge>` | GraphTraversal.`bothE(String... edgeLabels)` Map the `Vertex` to its incident edges given the edge labels.
    `static GraphTraversal<Vertex,Edge>` | __.`bothE(String... edgeLabels)`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`bothV()` Map the `Edge` to its incident vertices.
    `static GraphTraversal<Edge,Vertex>` | __.`bothV()`
    `static <A,M,B> GraphTraversal<A,B>` | __.`branch(Function<Traverser<A>,M> function)`
    `default <M,E2> GraphTraversal<S,E2>` | GraphTraversal.`branch(Function<Traverser<E>,M> function)` Split the `Traverser` to all the specified functions.
    `static <A,M,B> GraphTraversal<A,B>` | __.`branch(Traversal<?,M> traversalFunction)`
    `default <M,E2> GraphTraversal<S,E2>` | GraphTraversal.`branch(Traversal<?,M> branchTraversal)` Split the `Traverser` to all the specified traversals.
    `default GraphTraversal<S,E>` | GraphTraversal.`by()` The `by()` can be applied to a number of different step to alter their behaviors.
    `default GraphTraversal<S,E>` | GraphTraversal.`by(Comparator<E> comparator)` The `by()` can be applied to a number of different step to alter their behaviors.
    `default <U> GraphTraversal<S,E>` | GraphTraversal.`by(Function<U,Object> function, Comparator comparator)` The `by()` can be applied to a number of different step to alter their behaviors.
    `default <V> GraphTraversal<S,E>` | GraphTraversal.`by(Function<V,Object> function)` The `by()` can be applied to a number of different step to alter their behaviors.
    `default GraphTraversal<S,E>` | GraphTraversal.`by(Order order)` The `by()` can be applied to a number of different step to alter their behaviors.
    `default GraphTraversal<S,E>` | GraphTraversal.`by(String key)` The `by()` can be applied to a number of different step to alter their behaviors.
    `default <V> GraphTraversal<S,E>` | GraphTraversal.`by(String key, Comparator<V> comparator)` The `by()` can be applied to a number of different step to alter their behaviors.
    `default GraphTraversal<S,E>` | GraphTraversal.`by(T token)` The `by()` can be applied to a number of different step to alter their behaviors.
    `default GraphTraversal<S,E>` | GraphTraversal.`by(Traversal<?,?> traversal)` The `by()` can be applied to a number of different step to alter their behaviors.
    `default <V> GraphTraversal<S,E>` | GraphTraversal.`by(Traversal<?,?> traversal, Comparator<V> comparator)` The `by()` can be applied to a number of different step to alter their behaviors.
    `static <A,B> GraphTraversal<A,B>` | __.`cap(String sideEffectKey, String... sideEffectKeys)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`cap(String sideEffectKey, String... sideEffectKeys)` Iterates the traversal up to the itself and emits the side-effect referenced by the key.
    `static <A,M,B> GraphTraversal<A,B>` | __.`choose(Function<A,M> choiceFunction)`
    `default <M,E2> GraphTraversal<S,E2>` | GraphTraversal.`choose(Function<E,M> choiceFunction)` Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
    `static <A,B> GraphTraversal<A,B>` | __.`choose(Predicate<A> choosePredicate, Traversal<?,B> trueChoice)`
    `static <A,B> GraphTraversal<A,B>` | __.`choose(Predicate<A> choosePredicate, Traversal<?,B> trueChoice, Traversal<?,B> falseChoice)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`choose(Predicate<E> choosePredicate, Traversal<?,E2> trueChoice)` Routes the current traverser to a particular traversal branch option which allows the creation of if-then like semantics within a traversal.
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`choose(Predicate<E> choosePredicate, Traversal<?,E2> trueChoice, Traversal<?,E2> falseChoice)` Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`choose(Traversal<?,?> traversalPredicate, Traversal<?,E2> trueChoice)` Routes the current traverser to a particular traversal branch option which allows the creation of if-then like semantics within a traversal.
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`choose(Traversal<?,?> traversalPredicate, Traversal<?,E2> trueChoice, Traversal<?,E2> falseChoice)` Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
    `static <A,M,B> GraphTraversal<A,B>` | __.`choose(Traversal<?,M> traversalFunction)`
    `default <M,E2> GraphTraversal<S,E2>` | GraphTraversal.`choose(Traversal<?,M> choiceTraversal)` Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
    `static <A,M,B> GraphTraversal<A,B>` | __.`choose(Traversal<?,M> traversalPredicate, Traversal<?,B> trueChoice)`
    `static <A,M,B> GraphTraversal<A,B>` | __.`choose(Traversal<?,M> traversalPredicate, Traversal<?,B> trueChoice, Traversal<?,B> falseChoice)`
    `static <A,B> GraphTraversal<A,B>` | __.`coalesce(Traversal<?,B>... traversals)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`coalesce(Traversal<?,E2>... coalesceTraversals)` Evaluates the provided traversals and returns the result of the first traversal to emit at least one object.
    `default GraphTraversal<S,E>` | GraphTraversal.`coin(double probability)` Filter the `E` object given a biased coin toss.
    `static <A> GraphTraversal<A,A>` | __.`coin(double probability)`
    `default GraphTraversal<S,E>` | GraphTraversal.`connectedComponent()` Executes a Connected Component algorithm over the graph.
    `static <A> GraphTraversal<A,A>` | __.`constant(A a)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`constant(E2 e)` Map any object to a fixed `E` value.
    `default GraphTraversal<S,Long>` | GraphTraversal.`count()` Map the traversal stream to its reduction as a sum of the `Traverser.bulk()` values (i.e.
    `static <A> GraphTraversal<A,Long>` | __.`count()`
    `default GraphTraversal<S,Long>` | GraphTraversal.`count(Scope scope)` Map the traversal stream to its reduction as a sum of the `Traverser.bulk()` values given the specified `Scope` (i.e.
    `static <A> GraphTraversal<A,Long>` | __.`count(Scope scope)`
    `default GraphTraversal<S,E>` | GraphTraversal.`cyclicPath()` Filter the `E` object if its `Traverser.path()` is `Path.isSimple()`.
    `static <A> GraphTraversal<A,A>` | __.`cyclicPath()`
    `default GraphTraversal<S,E>` | GraphTraversal.`dedup(Scope scope, String... dedupLabels)` Remove all duplicates in the traversal stream up to this point.
    `static <A> GraphTraversal<A,A>` | __.`dedup(Scope scope, String... dedupLabels)`
    `default GraphTraversal<S,E>` | GraphTraversal.`dedup(String... dedupLabels)` Remove all duplicates in the traversal stream up to this point.
    `static <A> GraphTraversal<A,A>` | __.`dedup(String... dedupLabels)`
    `default GraphTraversal<S,E>` | GraphTraversal.`drop()` Removes elements and properties from the graph.
    `static <A> GraphTraversal<A,A>` | __.`drop()`
    `GraphTraversal<Edge,Edge>` | GraphTraversalSource.`E(Object... edgesIds)` Spawns a `GraphTraversal` starting with all edges or some subset of edges as specified by their unique identifier.
    `static <A extends Element,B> GraphTraversal<A,Map<Object,B>>` | __.`elementMap(String... propertyKeys)`
    `default <E2> GraphTraversal<S,Map<Object,E2>>` | GraphTraversal.`elementMap(String... propertyKeys)` Map the `Element` to a `Map` of the property values key'd according to their `Property.key()`.
    `default GraphTraversal<S,E>` | GraphTraversal.`emit()` Emit is used in conjunction with `repeat(Traversal)` to emit all objects from the loop.
    `static <A> GraphTraversal<A,A>` | __.`emit()`
    `static <A> GraphTraversal<A,A>` | __.`emit(Predicate<Traverser<A>> emitPredicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`emit(Predicate<Traverser<E>> emitPredicate)` Emit is used in conjunction with `repeat(Traversal)` to determine what objects get emit from the loop.
    `default GraphTraversal<S,E>` | GraphTraversal.`emit(Traversal<?,?> emitTraversal)` Emit is used in conjunction with `repeat(Traversal)` to determine what objects get emit from the loop.
    `static <A> GraphTraversal<A,A>` | __.`emit(Traversal<?,?> emitTraversal)`
    `static <A> GraphTraversal<A,A>` | __.`filter(Predicate<Traverser<A>> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`filter(Predicate<Traverser<E>> predicate)` Map the `Traverser` to either `true` or `false`, where `false` will not pass the traverser to the next step.
    `default GraphTraversal<S,E>` | GraphTraversal.`filter(Traversal<?,?> filterTraversal)` Map the `Traverser` to either `true` or `false`, where `false` will not pass the traverser to the next step.
    `static <A> GraphTraversal<A,A>` | __.`filter(Traversal<?,?> filterTraversal)`
    `static <A,B> GraphTraversal<A,B>` | __.`flatMap(Function<Traverser<A>,Iterator<B>> function)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`flatMap(Function<Traverser<E>,Iterator<E2>> function)` Map a `Traverser` referencing an object of type `E` to an iterator of objects of type `E2`.
    `static <A,B> GraphTraversal<A,B>` | __.`flatMap(Traversal<?,B> flatMapTraversal)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`flatMap(Traversal<?,E2> flatMapTraversal)` Map a `Traverser` referencing an object of type `E` to an iterator of objects of type `E2`.
    `default GraphTraversal<S,List<E>>` | GraphTraversal.`fold()` Rolls up objects in the stream into an aggregate list.
    `static <A> GraphTraversal<A,List<A>>` | __.`fold()`
    `static <A,B> GraphTraversal<A,B>` | __.`fold(B seed, BiFunction<B,A,B> foldFunction)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`fold(E2 seed, BiFunction<E2,E,E2> foldFunction)` Rolls up objects in the stream into an aggregate value as defined by a `seed` and `BiFunction`.
    `default GraphTraversal<S,E>` | GraphTraversal.`from(String fromStepLabel)` Provide `from()`-modulation to respective steps.
    `default GraphTraversal<S,E>` | GraphTraversal.`from(Traversal<?,Vertex> fromVertex)` When used as a modifier to `addE(String)` this method specifies the traversal to use for selecting the outgoing vertex of the newly added `Edge`.
    `default GraphTraversal<S,E>` | GraphTraversal.`from(Vertex fromVertex)` When used as a modifier to `addE(String)` this method specifies the traversal to use for selecting the outgoing vertex of the newly added `Edge`.
    `static <A,K,V> GraphTraversal<A,Map<K,V>>` | __.`group()`
    `default <K,V> GraphTraversal<S,Map<K,V>>` | GraphTraversal.`group()` Organize objects in the stream into a `Map`.
    `default GraphTraversal<S,E>` | GraphTraversal.`group(String sideEffectKey)` Organize objects in the stream into a `Map`.
    `static <A> GraphTraversal<A,A>` | __.`group(String sideEffectKey)`
    `static <A,K> GraphTraversal<A,Map<K,Long>>` | __.`groupCount()`
    `default <K> GraphTraversal<S,Map<K,Long>>` | GraphTraversal.`groupCount()` Counts the number of times a particular objects has been part of a traversal, returning a `Map` where the object is the key and the value is the count.
    `default GraphTraversal<S,E>` | GraphTraversal.`groupCount(String sideEffectKey)` Counts the number of times a particular objects has been part of a traversal, returning a `Map` where the object is the key and the value is the count.
    `static <A> GraphTraversal<A,A>` | __.`groupCount(String sideEffectKey)`
    `default GraphTraversal<S,E>` | GraphTraversal.`has(String propertyKey)` Filters vertices, edges and vertex properties based on the existence of properties.
    `static <A> GraphTraversal<A,A>` | __.`has(String propertyKey)`
    `default GraphTraversal<S,E>` | GraphTraversal.`has(String propertyKey, Object value)` Filters vertices, edges and vertex properties based on their properties.
    `static <A> GraphTraversal<A,A>` | __.`has(String propertyKey, Object value)`
    `default GraphTraversal<S,E>` | GraphTraversal.`has(String propertyKey, P<?> predicate)` Filters vertices, edges and vertex properties based on their properties.
    `static <A> GraphTraversal<A,A>` | __.`has(String propertyKey, P<?> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`has(String label, String propertyKey, Object value)` Filters vertices, edges and vertex properties based on their properties.
    `static <A> GraphTraversal<A,A>` | __.`has(String label, String propertyKey, Object value)`
    `default GraphTraversal<S,E>` | GraphTraversal.`has(String label, String propertyKey, P<?> predicate)` Filters vertices, edges and vertex properties based on their properties.
    `static <A> GraphTraversal<A,A>` | __.`has(String label, String propertyKey, P<?> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`has(String propertyKey, Traversal<?,?> propertyTraversal)` Filters vertices, edges and vertex properties based on the value of the specified property key.
    `static <A> GraphTraversal<A,A>` | __.`has(String propertyKey, Traversal<?,?> propertyTraversal)`
    `default GraphTraversal<S,E>` | GraphTraversal.`has(T accessor, Object value)` Filters vertices, edges and vertex properties based on their properties.
    `static <A> GraphTraversal<A,A>` | __.`has(T accessor, Object value)`
    `default GraphTraversal<S,E>` | GraphTraversal.`has(T accessor, P<?> predicate)` Filters vertices, edges and vertex properties based on their properties.
    `static <A> GraphTraversal<A,A>` | __.`has(T accessor, P<?> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`has(T accessor, Traversal<?,?> propertyTraversal)` Filters vertices, edges and vertex properties based on their value of `T` where only `T.id` and `T.label` are supported.
    `static <A> GraphTraversal<A,A>` | __.`has(T accessor, Traversal<?,?> propertyTraversal)`
    `default GraphTraversal<S,E>` | GraphTraversal.`hasId(Object id, Object... otherIds)` Filters vertices, edges and vertex properties based on their identifier.
    `static <A> GraphTraversal<A,A>` | __.`hasId(Object id, Object... otherIds)`
    `default GraphTraversal<S,E>` | GraphTraversal.`hasId(P<Object> predicate)` Filters vertices, edges and vertex properties based on their identifier.
    `static <A> GraphTraversal<A,A>` | __.`hasId(P<Object> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`hasKey(P<String> predicate)` Filters vertices, edges and vertex properties based on their key.
    `static <A> GraphTraversal<A,A>` | __.`hasKey(P<String> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`hasKey(String label, String... otherLabels)` Filters vertices, edges and vertex properties based on their key.
    `static <A> GraphTraversal<A,A>` | __.`hasKey(String label, String... otherLabels)`
    `default GraphTraversal<S,E>` | GraphTraversal.`hasLabel(P<String> predicate)` Filters vertices, edges and vertex properties based on their label.
    `static <A> GraphTraversal<A,A>` | __.`hasLabel(P<String> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`hasLabel(String label, String... otherLabels)` Filters vertices, edges and vertex properties based on their label.
    `static <A> GraphTraversal<A,A>` | __.`hasLabel(String label, String... otherLabels)`
    `default GraphTraversal<S,E>` | GraphTraversal.`hasNot(String propertyKey)` Filters vertices, edges and vertex properties based on the non-existence of properties.
    `static <A> GraphTraversal<A,A>` | __.`hasNot(String propertyKey)`
    `default GraphTraversal<S,E>` | GraphTraversal.`hasValue(Object value, Object... otherValues)` Filters vertices, edges and vertex properties based on their value.
    `static <A> GraphTraversal<A,A>` | __.`hasValue(Object value, Object... values)`
    `default GraphTraversal<S,E>` | GraphTraversal.`hasValue(P<Object> predicate)` Filters vertices, edges and vertex properties based on their value.
    `static <A> GraphTraversal<A,A>` | __.`hasValue(P<Object> predicate)`
    `default GraphTraversal<S,Object>` | GraphTraversal.`id()` Map the `Element` to its `Element.id()`.
    `static <A extends Element> GraphTraversal<A,Object>` | __.`id()`
    `default GraphTraversal<S,E>` | GraphTraversal.`identity()` Map the `E` object to itself.
    `static <A> GraphTraversal<A,A>` | __.`identity()`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`in(String... edgeLabels)` Map the `Vertex` to its incoming adjacent vertices given the edge labels.
    `static GraphTraversal<Vertex,Vertex>` | __.`in(String... edgeLabels)`
    `static <A,B> GraphTraversal<A,B>` | __.`index()`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`index()` Indexes all items of the current collection.
    `default GraphTraversal<S,Edge>` | GraphTraversal.`inE(String... edgeLabels)` Map the `Vertex` to its incoming incident edges given the edge labels.
    `static GraphTraversal<Vertex,Edge>` | __.`inE(String... edgeLabels)`
    `static <A> GraphTraversal<A,A>` | __.`inject(A... injections)`
    `default GraphTraversal<S,E>` | GraphTraversal.`inject(E... injections)` Provides a way to add arbitrary objects to a traversal stream.
    `<S> GraphTraversal<S,S>` | GraphTraversalSource.`inject(S... starts)` Spawns a `GraphTraversal` starting it with arbitrary values.
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`inV()` Map the `Edge` to its incoming/head incident `Vertex`.
    `static GraphTraversal<Edge,Vertex>` | __.`inV()`
    `<S> GraphTraversal<S,S>` | GraphTraversalSource.`io(String file)` Performs a read or write based operation on the `Graph` backing this `GraphTraversalSource`.
    `default GraphTraversal<S,E>` | GraphTraversal.`is(Object value)` Filter the `E` object if it is not `P.eq(V)` to the provided value.
    `static <A> GraphTraversal<A,A>` | __.`is(Object value)`
    `static <A> GraphTraversal<A,A>` | __.`is(P<A> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`is(P<E> predicate)` Filters `E` object values given the provided `predicate`.
    `GraphTraversal<S,E>` | DefaultGraphTraversal.`iterate()`
    `default GraphTraversal<S,E>` | GraphTraversal.`iterate()` Iterates the traversal presumably for the generation of side-effects.
    `default GraphTraversal<S,E>` | GraphTraversal.Admin.`iterate()`
    `default GraphTraversal<S,String>` | GraphTraversal.`key()` Map the `Property` to its `Property.key()`.
    `static <A extends Property> GraphTraversal<A,String>` | __.`key()`
    `default GraphTraversal<S,String>` | GraphTraversal.`label()` Map the `Element` to its `Element.label()`.
    `static <A extends Element> GraphTraversal<A,String>` | __.`label()`
    `default GraphTraversal<S,E>` | GraphTraversal.`limit(long limit)` Filter the objects in the traversal by the number of them to pass through the stream, where only the first `n` objects are allowed as defined by the `limit` argument.
    `static <A> GraphTraversal<A,A>` | __.`limit(long limit)`
    `static <A> GraphTraversal<A,A>` | __.`limit(Scope scope, long limit)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`limit(Scope scope, long limit)` Filter the objects in the traversal by the number of them to pass through the stream given the `Scope`, where only the first `n` objects are allowed as defined by the `limit` argument.
    `static <A,B> GraphTraversal<A,B>` | __.`local(Traversal<?,B> localTraversal)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`local(Traversal<?,E2> localTraversal)` Provides a execute a specified traversal on a single element within a stream.
    `default GraphTraversal<S,Integer>` | GraphTraversal.`loops()` If the `Traverser` supports looping then calling this method will extract the number of loops for that traverser.
    `static <A> GraphTraversal<A,Integer>` | __.`loops()`
    `default GraphTraversal<S,Integer>` | GraphTraversal.`loops(String loopName)` If the `Traverser` supports looping then calling this method will extract the number of loops for that traverser for the named loop.
    `static <A> GraphTraversal<A,Integer>` | __.`loops(String loopName)`
    `static <A,B> GraphTraversal<A,B>` | __.`map(Function<Traverser<A>,B> function)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`map(Function<Traverser<E>,E2> function)` Map a `Traverser` referencing an object of type `E` to an object of type `E2`.
    `static <A,B> GraphTraversal<A,B>` | __.`map(Traversal<?,B> mapTraversal)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`map(Traversal<?,E2> mapTraversal)` Map a `Traverser` referencing an object of type `E` to an object of type `E2`.
    `static <A,B> GraphTraversal<A,Map<String,B>>` | __.`match(Traversal<?,?>... matchTraversals)`
    `default <E2> GraphTraversal<S,Map<String,E2>>` | GraphTraversal.`match(Traversal<?,?>... matchTraversals)` Map the `Traverser` to a `Map` of bindings as specified by the provided match traversals.
    `default GraphTraversal<S,Double>` | GraphTraversal.`math(String expression)` Map the `Traverser` to a `Double` according to the mathematical expression provided in the argument.
    `static <A> GraphTraversal<A,Double>` | __.`math(String expression)`
    `static <A,B extends Comparable> GraphTraversal<A,B>` | __.`max()`
    `default <E2 extends Comparable> GraphTraversal<S,E2>` | GraphTraversal.`max()` Determines the largest value in the stream.
    `static <A,B extends Comparable> GraphTraversal<A,B>` | __.`max(Scope scope)`
    `default <E2 extends Comparable> GraphTraversal<S,E2>` | GraphTraversal.`max(Scope scope)` Determines the largest value in the stream given the `Scope`.
    `static <A> GraphTraversal<A,Double>` | __.`mean()`
    `default <E2 extends Number> GraphTraversal<S,E2>` | GraphTraversal.`mean()` Determines the mean value in the stream.
    `static <A> GraphTraversal<A,Double>` | __.`mean(Scope scope)`
    `default <E2 extends Number> GraphTraversal<S,E2>` | GraphTraversal.`mean(Scope scope)` Determines the mean value in the stream given the `Scope`.
    `static <A,B extends Comparable> GraphTraversal<A,B>` | __.`min()`
    `default <E2 extends Comparable> GraphTraversal<S,E2>` | GraphTraversal.`min()` Determines the smallest value in the stream.
    `static <A,B extends Comparable> GraphTraversal<A,B>` | __.`min(Scope scope)`
    `default <E2 extends Comparable> GraphTraversal<S,E2>` | GraphTraversal.`min(Scope scope)` Determines the smallest value in the stream given the `Scope`.
    `default GraphTraversal<S,E>` | GraphTraversal.`not(Traversal<?,?> notTraversal)` Removes objects from the traversal stream when the traversal provided as an argument does not return any objects.
    `static <A> GraphTraversal<A,A>` | __.`not(Traversal<?,?> notTraversal)`
    `default <M,E2> GraphTraversal<S,E>` | GraphTraversal.`option(M pickToken, Traversal<?,E2> traversalOption)` This step modifies `choose(Function)` to specifies the available choices that might be executed.
    `default <E2> GraphTraversal<S,E>` | GraphTraversal.`option(Traversal<?,E2> traversalOption)` This step modifies `choose(Function)` to specifies the available choices that might be executed.
    `static <A> GraphTraversal<A,A>` | __.`optional(Traversal<?,A> optionalTraversal)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`optional(Traversal<?,E2> optionalTraversal)` Returns the result of the specified traversal if it yields a result, otherwise it returns the calling element.
    `default GraphTraversal<S,E>` | GraphTraversal.`or(Traversal<?,?>... orTraversals)` Ensures that at least one of the provided traversals yield a result.
    `static <A> GraphTraversal<A,A>` | __.`or(Traversal<?,?>... orTraversals)`
    `default GraphTraversal<S,E>` | GraphTraversal.`order()` Order all the objects in the traversal up to this point and then emit them one-by-one in their ordered sequence.
    `static <A> GraphTraversal<A,A>` | __.`order()`
    `default GraphTraversal<S,E>` | GraphTraversal.`order(Scope scope)` Order either the `Scope.local` object (e.g.
    `static <A> GraphTraversal<A,A>` | __.`order(Scope scope)`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`otherV()` Map the `Edge` to the incident vertex that was not just traversed from in the path history.
    `static GraphTraversal<Edge,Vertex>` | __.`otherV()`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`out(String... edgeLabels)` Map the `Vertex` to its outgoing adjacent vertices given the edge labels.
    `static GraphTraversal<Vertex,Vertex>` | __.`out(String... edgeLabels)`
    `default GraphTraversal<S,Edge>` | GraphTraversal.`outE(String... edgeLabels)` Map the `Vertex` to its outgoing incident edges given the edge labels.
    `static GraphTraversal<Vertex,Edge>` | __.`outE(String... edgeLabels)`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`outV()` Map the `Edge` to its outgoing/tail incident `Vertex`.
    `static GraphTraversal<Edge,Vertex>` | __.`outV()`
    `default GraphTraversal<S,E>` | GraphTraversal.`pageRank()` Calculates a PageRank over the graph using a 0.85 for the `alpha` value.
    `default GraphTraversal<S,E>` | GraphTraversal.`pageRank(double alpha)` Calculates a PageRank over the graph.
    `default GraphTraversal<S,Path>` | GraphTraversal.`path()` Map the `Traverser` to its `Path` history via `Traverser.path()`.
    `static <A> GraphTraversal<A,Path>` | __.`path()`
    `default GraphTraversal<S,E>` | GraphTraversal.`peerPressure()` Executes a Peer Pressure community detection algorithm over the graph.
    `default GraphTraversal<S,TraversalMetrics>` | GraphTraversal.`profile()` Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
    `default GraphTraversal<S,E>` | GraphTraversal.`profile(String sideEffectKey)` Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
    `default GraphTraversal<S,E>` | GraphTraversal.`program(VertexProgram<?> vertexProgram)` Executes an arbitrary `VertexProgram` over the graph.
    `static <A,B> GraphTraversal<A,Map<String,B>>` | __.`project(String projectKey, String... projectKeys)`
    `default <E2> GraphTraversal<S,Map<String,E2>>` | GraphTraversal.`project(String projectKey, String... otherProjectKeys)` Projects the current object in the stream into a `Map` that is keyed by the provided labels.
    `static <A extends Element,B> GraphTraversal<A,? extends Property<B>>` | __.`properties(String... propertyKeys)`
    `default <E2> GraphTraversal<S,? extends Property<E2>>` | GraphTraversal.`properties(String... propertyKeys)` Map the `Element` to its associated properties given the provide property keys.
    `default GraphTraversal<S,E>` | GraphTraversal.`property(Object key, Object value, Object... keyValues)` Sets the key and value of a `Property`.
    `static <A> GraphTraversal<A,A>` | __.`property(Object key, Object value, Object... keyValues)`
    `default GraphTraversal<S,E>` | GraphTraversal.`property(VertexProperty.Cardinality cardinality, Object key, Object value, Object... keyValues)` Sets a `Property` value and related meta properties if supplied, if supported by the `Graph` and if the `Element` is a `VertexProperty`.
    `static <A> GraphTraversal<A,A>` | __.`property(VertexProperty.Cardinality cardinality, Object key, Object value, Object... keyValues)`
    `static <A extends Element,B> GraphTraversal<A,Map<String,B>>` | __.`propertyMap(String... propertyKeys)`
    `default <E2> GraphTraversal<S,Map<String,E2>>` | GraphTraversal.`propertyMap(String... propertyKeys)` Map the `Element` to a `Map` of the properties key'd according to their `Property.key()`.
    `default GraphTraversal<S,E>` | GraphTraversal.`range(long low, long high)` Filter the objects in the traversal by the number of them to pass through the stream.
    `static <A> GraphTraversal<A,A>` | __.`range(long low, long high)`
    `static <A> GraphTraversal<A,A>` | __.`range(Scope scope, long low, long high)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`range(Scope scope, long low, long high)` Filter the objects in the traversal by the number of them to pass through the stream as constrained by the `Scope`.
    `default GraphTraversal<S,E>` | GraphTraversal.`read()` This step is technically a step modulator for the the `GraphTraversalSource.io(String)` step which instructs the step to perform a read with its given configuration.
    `static <A> GraphTraversal<A,A>` | __.`repeat(String loopName, Traversal<?,A> traversal)`
    `default GraphTraversal<S,E>` | GraphTraversal.`repeat(String loopName, Traversal<?,E> repeatTraversal)` This step is used for looping over a traversal given some break predicate and with a specified loop name.
    `static <A> GraphTraversal<A,A>` | __.`repeat(Traversal<?,A> traversal)`
    `default GraphTraversal<S,E>` | GraphTraversal.`repeat(Traversal<?,E> repeatTraversal)` This step is used for looping over a traversal given some break predicate.
    `static <A,B> GraphTraversal<A,B>` | __.`sack()`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`sack()` Map the `Traverser` to its `Traverser.sack()` value.
    `static <A,V,U> GraphTraversal<A,A>` | __.`sack(BiFunction<V,U,V> sackOperator)`
    `default <V,U> GraphTraversal<S,E>` | GraphTraversal.`sack(BiFunction<V,U,V> sackOperator)` Map the `Traverser` to its `Traverser.sack()` value.
    `default GraphTraversal<S,E>` | GraphTraversal.`sample(int amountToSample)` Allow some specified number of objects to pass through the stream.
    `static <A> GraphTraversal<A,A>` | __.`sample(int amountToSample)`
    `default GraphTraversal<S,E>` | GraphTraversal.`sample(Scope scope, int amountToSample)` Allow some specified number of objects to pass through the stream.
    `static <A> GraphTraversal<A,A>` | __.`sample(Scope scope, int amountToSample)`
    `static <A,B> GraphTraversal<A,Collection<B>>` | __.`select(Column column)`
    `default <E2> GraphTraversal<S,Collection<E2>>` | GraphTraversal.`select(Column column)` A version of `select` that allows for the extraction of a `Column` from objects in the traversal.
    `static <A,B> GraphTraversal<A,B>` | __.`select(Pop pop, String selectKey)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`select(Pop pop, String selectKey)` Map the `Traverser` to the object specified by the `selectKey` and apply the `Pop` operation to it.
    `static <A,B> GraphTraversal<A,Map<String,B>>` | __.`select(Pop pop, String selectKey1, String selectKey2, String... otherSelectKeys)`
    `default <E2> GraphTraversal<S,Map<String,E2>>` | GraphTraversal.`select(Pop pop, String selectKey1, String selectKey2, String... otherSelectKeys)` Map the `Traverser` to a `Map` projection of sideEffect values, map values, and/or path values.
    `static <A,B> GraphTraversal<A,B>` | __.`select(Pop pop, Traversal<A,B> keyTraversal)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`select(Pop pop, Traversal<S,E2> keyTraversal)` Map the `Traverser` to the object specified by the key returned by the `keyTraversal` and apply the `Pop` operation to it.
    `static <A,B> GraphTraversal<A,B>` | __.`select(String selectKey)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`select(String selectKey)` Map the `Traverser` to the object specified by the `selectKey`.
    `static <A,B> GraphTraversal<A,Map<String,B>>` | __.`select(String selectKey1, String selectKey2, String... otherSelectKeys)`
    `default <E2> GraphTraversal<S,Map<String,E2>>` | GraphTraversal.`select(String selectKey1, String selectKey2, String... otherSelectKeys)` Map the `Traverser` to a `Map` projection of sideEffect values, map values, and/or path values.
    `static <A,B> GraphTraversal<A,B>` | __.`select(Traversal<A,B> keyTraversal)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`select(Traversal<S,E2> keyTraversal)` Map the `Traverser` to the object specified by the key returned by the `keyTraversal`.
    `default GraphTraversal<S,Path>` | GraphTraversal.`shortestPath()` Executes a Shortest Path algorithm over the graph.
    `static <A> GraphTraversal<A,A>` | __.`sideEffect(Consumer<Traverser<A>> consumer)`
    `default GraphTraversal<S,E>` | GraphTraversal.`sideEffect(Consumer<Traverser<E>> consumer)` Perform some operation on the `Traverser` and pass it to the next step unmodified.
    `default GraphTraversal<S,E>` | GraphTraversal.`sideEffect(Traversal<?,?> sideEffectTraversal)` Perform some operation on the `Traverser` and pass it to the next step unmodified.
    `static <A> GraphTraversal<A,A>` | __.`sideEffect(Traversal<?,?> sideEffectTraversal)`
    `default GraphTraversal<S,E>` | GraphTraversal.`simplePath()` Filter the `E` object if its `Traverser.path()` is not `Path.isSimple()`.
    `static <A> GraphTraversal<A,A>` | __.`simplePath()`
    `default GraphTraversal<S,E>` | GraphTraversal.`skip(long skip)` Filters out the first `n` objects in the traversal.
    `static <A> GraphTraversal<A,A>` | __.`skip(long skip)`
    `static <A> GraphTraversal<A,A>` | __.`skip(Scope scope, long skip)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`skip(Scope scope, long skip)` Filters out the first `n` objects in the traversal.
    `static <A> GraphTraversal<A,A>` | __.`start()`
    `default GraphTraversal<S,E>` | GraphTraversal.`store(String sideEffectKey)` Deprecated. As of release 3.4.3, replaced by `aggregate(Scope, String)` using `Scope.local`.
    `static <A> GraphTraversal<A,A>` | __.`store(String sideEffectKey)` Deprecated. As of release 3.4.3, replaced by `__.aggregate(Scope, String)` using `Scope.local`.
    `default GraphTraversal<S,Edge>` | GraphTraversal.`subgraph(String sideEffectKey)` Extracts a portion of the graph being traversed into a `Graph` object held in the specified side-effect key.
    `static <A> GraphTraversal<A,Edge>` | __.`subgraph(String sideEffectKey)`
    `static <A> GraphTraversal<A,Double>` | __.`sum()`
    `default <E2 extends Number> GraphTraversal<S,E2>` | GraphTraversal.`sum()` Map the traversal stream to its reduction as a sum of the `Traverser.get()` values multiplied by their `Traverser.bulk()` (i.e.
    `static <A> GraphTraversal<A,Double>` | __.`sum(Scope scope)`
    `default <E2 extends Number> GraphTraversal<S,E2>` | GraphTraversal.`sum(Scope scope)` Map the traversal stream to its reduction as a sum of the `Traverser.get()` values multiplied by their `Traverser.bulk()` given the specified `Scope` (i.e.
    `default GraphTraversal<S,E>` | GraphTraversal.`tail()` Filters the objects in the traversal emitted as being last objects in the stream.
    `static <A> GraphTraversal<A,A>` | __.`tail()`
    `default GraphTraversal<S,E>` | GraphTraversal.`tail(long limit)` Filters the objects in the traversal emitted as being last objects in the stream.
    `static <A> GraphTraversal<A,A>` | __.`tail(long limit)`
    `static <A> GraphTraversal<A,A>` | __.`tail(Scope scope)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`tail(Scope scope)` Filters the objects in the traversal emitted as being last objects in the stream given the `Scope`.
    `static <A> GraphTraversal<A,A>` | __.`tail(Scope scope, long limit)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`tail(Scope scope, long limit)` Filters the objects in the traversal emitted as being last objects in the stream given the `Scope`.
    `default GraphTraversal<S,E>` | GraphTraversal.`timeLimit(long timeLimit)` Once the first `Traverser` hits this step, a count down is started.
    `static <A> GraphTraversal<A,A>` | __.`timeLimit(long timeLimit)`
    `default GraphTraversal<S,E>` | GraphTraversal.`times(int maxLoops)` Modifies a `repeat(Traversal)` to specify how many loops should occur before exiting.
    `static <A> GraphTraversal<A,A>` | __.`times(int maxLoops)`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`to(Direction direction, String... edgeLabels)` Map the `Vertex` to its adjacent vertices given a direction and edge labels.
    `static GraphTraversal<Vertex,Vertex>` | __.`to(Direction direction, String... edgeLabels)`
    `default GraphTraversal<S,E>` | GraphTraversal.`to(String toStepLabel)` Provide `to()`-modulation to respective steps.
    `default GraphTraversal<S,E>` | GraphTraversal.`to(Traversal<?,Vertex> toVertex)` When used as a modifier to `addE(String)` this method specifies the traversal to use for selecting the incoming vertex of the newly added `Edge`.
    `default GraphTraversal<S,E>` | GraphTraversal.`to(Vertex toVertex)` When used as a modifier to `addE(String)` this method specifies the traversal to use for selecting the incoming vertex of the newly added `Edge`.
    `default GraphTraversal<S,Edge>` | GraphTraversal.`toE(Direction direction, String... edgeLabels)` Map the `Vertex` to its incident edges given the direction and edge labels.
    `static GraphTraversal<Vertex,Edge>` | __.`toE(Direction direction, String... edgeLabels)`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`toV(Direction direction)` Map the `Edge` to its incident vertices given the direction.
    `static GraphTraversal<Edge,Vertex>` | __.`toV(Direction direction)`
    `default GraphTraversal<S,Tree>` | GraphTraversal.`tree()` Aggregates the emanating paths into a `Tree` data structure.
    `static <A> GraphTraversal<A,Tree>` | __.`tree()`
    `default GraphTraversal<S,E>` | GraphTraversal.`tree(String sideEffectKey)` Aggregates the emanating paths into a `Tree` data structure.
    `static <A> GraphTraversal<A,A>` | __.`tree(String sideEffectKey)`
    `static <A> GraphTraversal<A,A>` | __.`unfold()`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`unfold()` Unrolls a `Iterator`, `Iterable` or `Map` into a linear form or simply emits the object if it is not one of those types.
    `static <A,B> GraphTraversal<A,B>` | __.`union(Traversal<?,B>... traversals)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`union(Traversal<?,E2>... unionTraversals)` Merges the results of an arbitrary number of traversals.
    `static <A> GraphTraversal<A,A>` | __.`until(Predicate<Traverser<A>> untilPredicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`until(Predicate<Traverser<E>> untilPredicate)` Modifies a `repeat(Traversal)` to determine when the loop should exit.
    `default GraphTraversal<S,E>` | GraphTraversal.`until(Traversal<?,?> untilTraversal)` Modifies a `repeat(Traversal)` to determine when the loop should exit.
    `static <A> GraphTraversal<A,A>` | __.`until(Traversal<?,?> untilTraversal)`
    `default GraphTraversal<S,Vertex>` | GraphTraversal.`V(Object... vertexIdsOrElements)` A `V` step is usually used to start a traversal but it may also be used mid-traversal.
    `GraphTraversal<Vertex,Vertex>` | GraphTraversalSource.`V(Object... vertexIds)` Spawns a `GraphTraversal` starting with all vertices or some subset of vertices as specified by their unique identifier.
    `static <A> GraphTraversal<A,Vertex>` | __.`V(Object... vertexIdsOrElements)`
    `static <A extends Property,B> GraphTraversal<A,B>` | __.`value()`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`value()` Map the `Property` to its `Property.value()`.
    `static <A extends Element,B> GraphTraversal<A,Map<Object,B>>` | __.`valueMap(boolean includeTokens, String... propertyKeys)` Deprecated. As of release 3.4.0, deprecated in favor of `__.valueMap(String...)` in conjunction with `with(String, Object)`.
    `default <E2> GraphTraversal<S,Map<Object,E2>>` | GraphTraversal.`valueMap(boolean includeTokens, String... propertyKeys)` Deprecated. As of release 3.4.0, deprecated in favor of `valueMap(String...)` in conjunction with `with(String, Object)` or simple prefer `elementMap(String...)`.
    `static <A extends Element,B> GraphTraversal<A,Map<Object,B>>` | __.`valueMap(String... propertyKeys)`
    `default <E2> GraphTraversal<S,Map<Object,E2>>` | GraphTraversal.`valueMap(String... propertyKeys)` Map the `Element` to a `Map` of the property values key'd according to their `Property.key()`.
    `static <A extends Element,B> GraphTraversal<A,B>` | __.`values(String... propertyKeys)`
    `default <E2> GraphTraversal<S,E2>` | GraphTraversal.`values(String... propertyKeys)` Map the `Element` to the values of the associated properties given the provide property keys.
    `default GraphTraversal<S,E>` | GraphTraversal.`where(P<String> predicate)` Filters the current object based on the object itself or the path history.
    `static <A> GraphTraversal<A,A>` | __.`where(P<String> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`where(String startKey, P<String> predicate)` Filters the current object based on the object itself or the path history.
    `static <A> GraphTraversal<A,A>` | __.`where(String startKey, P<String> predicate)`
    `default GraphTraversal<S,E>` | GraphTraversal.`where(Traversal<?,?> whereTraversal)` Filters the current object based on the object itself or the path history.
    `static <A> GraphTraversal<A,A>` | __.`where(Traversal<?,?> whereTraversal)`
    `default GraphTraversal<S,E>` | GraphTraversal.`with(String key)` Provides a configuration to a step in the form of a key which is the same as `with(key, true)`.
    `default GraphTraversal<S,E>` | GraphTraversal.`with(String key, Object value)` Provides a configuration to a step in the form of a key and value pair.
    `default GraphTraversal<S,E>` | GraphTraversal.`write()` This step is technically a step modulator for the the `GraphTraversalSource.io(String)` step which instructs the step to perform a write with its given configuration.

Copyright © 2013–2020 Apache Software Foundation. All rights reserved.