org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential

## Interface CredentialTraversal<S,E>

- All Superinterfaces:
    AutoCloseable, Cloneable, CredentialTraversalDsl<S,E>, GraphTraversal<S,E>, GraphTraversal.Admin<S,E>, Iterator<E>, Serializable, Traversal<S,E>, Traversal.Admin<S,E>
  All Known Implementing Classes:
    DefaultCredentialTraversal

      public interface CredentialTraversal<S,E>
      extends CredentialTraversalDsl<S,E>

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal

      `GraphTraversal.Admin<S,E>, GraphTraversal.Symbols`

    - ### Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal

      `Traversal.Exceptions`

  - ### Field Summary

    - ### Fields inherited from interface org.apache.tinkerpop.gremlin.groovy.jsr223.dsl.credential.CredentialTraversalDsl

      `BCRYPT_ROUNDS`

  - ### Method Summary

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

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.Admin

      `addStep, clone`

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal.Admin

      `addStart, addStarts, addStep, applyStrategies, equals, getBytecode, getEndStep, getGraph, getParent, getSideEffects, getStartStep, getSteps, getStrategies, getTraversalSource, getTraverserGenerator, getTraverserRequirements, getTraverserSetSupplier, isLocked, isRoot, nextTraverser, removeStep, removeStep, reset, setGraph, setParent, setSideEffects, setStrategies`

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal

      `asAdmin`

    - ### Methods inherited from interface org.apache.tinkerpop.gremlin.process.traversal.Traversal

      `close, explain, fill, forEachRemaining, forEachRemaining, next, notifyClose, promise, toBulkSet, toList, toSet, toStream, tryNext`

    - ### Methods inherited from interface java.util.Iterator

      `hasNext, next, remove`

- - ### Method Detail

    - #### users

          default CredentialTraversal<S,Vertex> users()

      Description copied from interface: `CredentialTraversalDsl`
      Finds all users.
      Specified by:
        `users` in interface `CredentialTraversalDsl<S,E>`

    - #### users

          default CredentialTraversal<S,Vertex> users(String username,
                                                      String... more)

      Description copied from interface: `CredentialTraversalDsl`
      Finds users by name.
      Specified by:
        `users` in interface `CredentialTraversalDsl<S,E>`

    - #### user

          default CredentialTraversal<S,Vertex> user(String username,
                                                     String password)

      Description copied from interface: `CredentialTraversalDsl`
      Creates or updates a user.
      Specified by:
        `user` in interface `CredentialTraversalDsl<S,E>`

    - #### map

          default <E2> CredentialTraversal<S,E2> map(Function<Traverser<E>,E2> function)

      Description copied from interface: `GraphTraversal`
      Map a `Traverser` referencing an object of type `E` to an object of type `E2`.
      Specified by:
        `map` in interface `GraphTraversal<S,E>`
      Parameters:
        `function` - the lambda expression that does the functional mapping
      Returns:
        the traversal with an appended `LambdaMapStep`.
      See Also:
        Reference Documentation - General Steps

    - #### map

          default <E2> CredentialTraversal<S,E2> map(Traversal<?,E2> mapTraversal)

      Description copied from interface: `GraphTraversal`
      Map a `Traverser` referencing an object of type `E` to an object of type `E2`.
      Specified by:
        `map` in interface `GraphTraversal<S,E>`
      Parameters:
        `mapTraversal` - the traversal expression that does the functional mapping
      Returns:
        the traversal with an appended `LambdaMapStep`.
      See Also:
        Reference Documentation - General Steps

    - #### flatMap

          default <E2> CredentialTraversal<S,E2> flatMap(Function<Traverser<E>,Iterator<E2>> function)

      Description copied from interface: `GraphTraversal`
      Map a `Traverser` referencing an object of type `E` to an iterator of objects of type `E2`. The resultant iterator is drained one-by-one before a new `E` object is pulled in for processing.
      Specified by:
        `flatMap` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the type of the returned iterator objects
      Parameters:
        `function` - the lambda expression that does the functional mapping
      Returns:
        the traversal with an appended `LambdaFlatMapStep`.
      See Also:
        Reference Documentation - General Steps

    - #### flatMap

          default <E2> CredentialTraversal<S,E2> flatMap(Traversal<?,E2> flatMapTraversal)

      Description copied from interface: `GraphTraversal`
      Map a `Traverser` referencing an object of type `E` to an iterator of objects of type `E2`. The internal traversal is drained one-by-one before a new `E` object is pulled in for processing.
      Specified by:
        `flatMap` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the end type of the internal traversal
      Parameters:
        `flatMapTraversal` - the traversal generating objects of type `E2`
      Returns:
        the traversal with an appended `TraversalFlatMapStep`.
      See Also:
        Reference Documentation - General Steps

    - #### id

          default CredentialTraversal<S,Object> id()

      Description copied from interface: `GraphTraversal`
      Map the `Element` to its `Element.id()`.
      Specified by:
        `id` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `IdStep`.
      See Also:
        Reference Documentation - Id Step

    - #### label

          default CredentialTraversal<S,String> label()

      Description copied from interface: `GraphTraversal`
      Map the `Element` to its `Element.label()`.
      Specified by:
        `label` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `LabelStep`.
      See Also:
        Reference Documentation - Label Step

    - #### identity

          default CredentialTraversal<S,E> identity()

      Description copied from interface: `GraphTraversal`
      Map the `E` object to itself. In other words, a "no op."
      Specified by:
        `identity` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `IdentityStep`.

    - #### constant

          default <E2> CredentialTraversal<S,E2> constant(E2 e)

      Description copied from interface: `GraphTraversal`
      Map any object to a fixed `E` value.
      Specified by:
        `constant` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `ConstantStep`.
      See Also:
        Reference Documentation - Constant Step

    - #### V

          default CredentialTraversal<S,Vertex> V(Object... vertexIdsOrElements)

      Description copied from interface: `GraphTraversal`
      A `V` step is usually used to start a traversal but it may also be used mid-traversal.
      Specified by:
        `V` in interface `GraphTraversal<S,E>`
      Parameters:
        `vertexIdsOrElements` - vertices to inject into the traversal
      Returns:
        the traversal with an appended `GraphStep`
      See Also:
        Reference Documentation - Graph Step

    - #### to

          default CredentialTraversal<S,Vertex> to(Direction direction,
                                                   String... edgeLabels)

      Description copied from interface: `GraphTraversal`
      Map the `Vertex` to its adjacent vertices given a direction and edge labels.
      Specified by:
        `to` in interface `GraphTraversal<S,E>`
      Parameters:
        `direction` - the direction to traverse from the current vertex
        `edgeLabels` - the edge labels to traverse
      Returns:
        the traversal with an appended `VertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### out

          default CredentialTraversal<S,Vertex> out(String... edgeLabels)

      Description copied from interface: `GraphTraversal`
      Map the `Vertex` to its outgoing adjacent vertices given the edge labels.
      Specified by:
        `out` in interface `GraphTraversal<S,E>`
      Parameters:
        `edgeLabels` - the edge labels to traverse
      Returns:
        the traversal with an appended `VertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### in

          default CredentialTraversal<S,Vertex> in(String... edgeLabels)

      Description copied from interface: `GraphTraversal`
      Map the `Vertex` to its incoming adjacent vertices given the edge labels.
      Specified by:
        `in` in interface `GraphTraversal<S,E>`
      Parameters:
        `edgeLabels` - the edge labels to traverse
      Returns:
        the traversal with an appended `VertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### both

          default CredentialTraversal<S,Vertex> both(String... edgeLabels)

      Description copied from interface: `GraphTraversal`
      Map the `Vertex` to its adjacent vertices given the edge labels.
      Specified by:
        `both` in interface `GraphTraversal<S,E>`
      Parameters:
        `edgeLabels` - the edge labels to traverse
      Returns:
        the traversal with an appended `VertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### toE

          default CredentialTraversal<S,Edge> toE(Direction direction,
                                                  String... edgeLabels)

      Description copied from interface: `GraphTraversal`
      Map the `Vertex` to its incident edges given the direction and edge labels.
      Specified by:
        `toE` in interface `GraphTraversal<S,E>`
      Parameters:
        `direction` - the direction to traverse from the current vertex
        `edgeLabels` - the edge labels to traverse
      Returns:
        the traversal with an appended `VertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### outE

          default CredentialTraversal<S,Edge> outE(String... edgeLabels)

      Description copied from interface: `GraphTraversal`
      Map the `Vertex` to its outgoing incident edges given the edge labels.
      Specified by:
        `outE` in interface `GraphTraversal<S,E>`
      Parameters:
        `edgeLabels` - the edge labels to traverse
      Returns:
        the traversal with an appended `VertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### inE

          default CredentialTraversal<S,Edge> inE(String... edgeLabels)

      Description copied from interface: `GraphTraversal`
      Map the `Vertex` to its incoming incident edges given the edge labels.
      Specified by:
        `inE` in interface `GraphTraversal<S,E>`
      Parameters:
        `edgeLabels` - the edge labels to traverse
      Returns:
        the traversal with an appended `VertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### bothE

          default CredentialTraversal<S,Edge> bothE(String... edgeLabels)

      Description copied from interface: `GraphTraversal`
      Map the `Vertex` to its incident edges given the edge labels.
      Specified by:
        `bothE` in interface `GraphTraversal<S,E>`
      Parameters:
        `edgeLabels` - the edge labels to traverse
      Returns:
        the traversal with an appended `VertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### toV

          default CredentialTraversal<S,Vertex> toV(Direction direction)

      Description copied from interface: `GraphTraversal`
      Map the `Edge` to its incident vertices given the direction.
      Specified by:
        `toV` in interface `GraphTraversal<S,E>`
      Parameters:
        `direction` - the direction to traverser from the current edge
      Returns:
        the traversal with an appended `EdgeVertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### inV

          default CredentialTraversal<S,Vertex> inV()

      Description copied from interface: `GraphTraversal`
      Map the `Edge` to its incoming/head incident `Vertex`.
      Specified by:
        `inV` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `EdgeVertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### outV

          default CredentialTraversal<S,Vertex> outV()

      Description copied from interface: `GraphTraversal`
      Map the `Edge` to its outgoing/tail incident `Vertex`.
      Specified by:
        `outV` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `EdgeVertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### bothV

          default CredentialTraversal<S,Vertex> bothV()

      Description copied from interface: `GraphTraversal`
      Map the `Edge` to its incident vertices.
      Specified by:
        `bothV` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `EdgeVertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### otherV

          default CredentialTraversal<S,Vertex> otherV()

      Description copied from interface: `GraphTraversal`
      Map the `Edge` to the incident vertex that was not just traversed from in the path history.
      Specified by:
        `otherV` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `EdgeOtherVertexStep`.
      See Also:
        Reference Documentation - Vertex Step

    - #### order

          default CredentialTraversal<S,E> order()

      Description copied from interface: `GraphTraversal`
      Order all the objects in the traversal up to this point and then emit them one-by-one in their ordered sequence.
      Specified by:
        `order` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `OrderGlobalStep`.
      See Also:
        Reference Documentation - Order Step

    - #### order

          default CredentialTraversal<S,E> order(Scope scope)

      Description copied from interface: `GraphTraversal`
      Order either the `Scope.local` object (e.g. a list, map, etc.) or the entire `Scope.global` traversal stream.
      Specified by:
        `order` in interface `GraphTraversal<S,E>`
      Parameters:
        `scope` - whether the ordering is the current local object or the entire global stream.
      Returns:
        the traversal with an appended `OrderGlobalStep` or `OrderLocalStep` depending on the `scope`.
      See Also:
        Reference Documentation - Order Step

    - #### properties

          default <E2> CredentialTraversal<S,? extends Property<E2>> properties(String... propertyKeys)

      Description copied from interface: `GraphTraversal`
      Map the `Element` to its associated properties given the provide property keys. If no property keys are provided, then all properties are emitted.
      Specified by:
        `properties` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the value type of the returned properties
      Parameters:
        `propertyKeys` - the properties to retrieve
      Returns:
        the traversal with an appended `PropertiesStep`.
      See Also:
        Reference Documentation - Properties Step

    - #### values

          default <E2> CredentialTraversal<S,E2> values(String... propertyKeys)

      Description copied from interface: `GraphTraversal`
      Map the `Element` to the values of the associated properties given the provide property keys. If no property keys are provided, then all property values are emitted.
      Specified by:
        `values` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the value type of the properties
      Parameters:
        `propertyKeys` - the properties to retrieve their value from
      Returns:
        the traversal with an appended `PropertiesStep`.
      See Also:
        Reference Documentation - Values Step

    - #### propertyMap

          default <E2> CredentialTraversal<S,Map<String,E2>> propertyMap(String... propertyKeys)

      Description copied from interface: `GraphTraversal`
      Map the `Element` to a `Map` of the properties key'd according to their `Property.key()`. If no property keys are provided, then all properties are retrieved.
      Specified by:
        `propertyMap` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the value type of the returned properties
      Parameters:
        `propertyKeys` - the properties to retrieve
      Returns:
        the traversal with an appended `PropertyMapStep`.
      See Also:
        Reference Documentation - PropertyMap Step

    - #### elementMap

          default <E2> CredentialTraversal<S,Map<Object,E2>> elementMap(String... propertyKeys)

      Description copied from interface: `GraphTraversal`
      Map the `Element` to a `Map` of the property values key'd according to their `Property.key()`. If no property keys are provided, then all property values are retrieved. For vertices, the `Map` will be returned with the assumption of single property values along with `T.id` and `T.label`. Prefer `GraphTraversal.valueMap(String...)` if multi-property processing is required. For edges, keys will include additional related edge structure of `Direction.IN` and `Direction.OUT` which themselves are `Map` instances of the particular `Vertex` represented by `T.id` and `T.label`.
      Specified by:
        `elementMap` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the value type of the returned properties
      Parameters:
        `propertyKeys` - the properties to retrieve
      Returns:
        the traversal with an appended `ElementMapStep`.
      See Also:
        Reference Documentation - ElementMap Step

    - #### valueMap

          default <E2> CredentialTraversal<S,Map<Object,E2>> valueMap(String... propertyKeys)

      Description copied from interface: `GraphTraversal`
      Map the `Element` to a `Map` of the property values key'd according to their `Property.key()`. If no property keys are provided, then all property values are retrieved.
      Specified by:
        `valueMap` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the value type of the returned properties
      Parameters:
        `propertyKeys` - the properties to retrieve
      Returns:
        the traversal with an appended `PropertyMapStep`.
      See Also:
        Reference Documentation - ValueMap Step

    - #### valueMap

          default <E2> CredentialTraversal<S,Map<Object,E2>> valueMap(boolean includeTokens,
                                                                      String... propertyKeys)

      Description copied from interface: `GraphTraversal`
      Map the `Element` to a `Map` of the property values key'd according to their `Property.key()`. If no property keys are provided, then all property values are retrieved.
      Specified by:
        `valueMap` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the value type of the returned properties
      Parameters:
        `includeTokens` - whether to include `T` tokens in the emitted map.
        `propertyKeys` - the properties to retrieve
      Returns:
        the traversal with an appended `PropertyMapStep`.
      See Also:
        Reference Documentation - ValueMap Step

    - #### key

          default CredentialTraversal<S,String> key()

      Description copied from interface: `GraphTraversal`
      Map the `Property` to its `Property.key()`.
      Specified by:
        `key` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `PropertyKeyStep`.
      See Also:
        Reference Documentation - Key Step

    - #### value

          default <E2> CredentialTraversal<S,E2> value()

      Description copied from interface: `GraphTraversal`
      Map the `Property` to its `Property.value()`.
      Specified by:
        `value` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `PropertyValueStep`.
      See Also:
        Reference Documentation - Value Step

    - #### path

          default CredentialTraversal<S,Path> path()

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to its `Path` history via `Traverser.path()`.
      Specified by:
        `path` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `PathStep`.
      See Also:
        Reference Documentation - Path Step

    - #### match

          default <E2> CredentialTraversal<S,Map<String,E2>> match(Traversal<?,?>... matchTraversals)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to a `Map` of bindings as specified by the provided match traversals.
      Specified by:
        `match` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the type of the objects bound in the variables
      Parameters:
        `matchTraversals` - the traversal that maintain variables which must hold for the life of the traverser
      Returns:
        the traversal with an appended `MatchStep`.
      See Also:
        Reference Documentation - Match Step

    - #### sack

          default <E2> CredentialTraversal<S,E2> sack()

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to its `Traverser.sack()` value.
      Specified by:
        `sack` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the sack value type
      Returns:
        the traversal with an appended `SackStep`.
      See Also:
        Reference Documentation - Sack Step

    - #### loops

          default CredentialTraversal<S,Integer> loops()

      Description copied from interface: `GraphTraversal`
      If the `Traverser` supports looping then calling this method will extract the number of loops for that traverser.
      Specified by:
        `loops` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `LoopsStep`
      See Also:
        Reference Documentation - Loops Step

    - #### loops

          default CredentialTraversal<S,Integer> loops(String loopName)

      Description copied from interface: `GraphTraversal`
      If the `Traverser` supports looping then calling this method will extract the number of loops for that traverser for the named loop.
      Specified by:
        `loops` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `LoopsStep`
      See Also:
        Reference Documentation - Loops Step

    - #### project

          default <E2> CredentialTraversal<S,Map<String,E2>> project(String projectKey,
                                                                     String... otherProjectKeys)

      Description copied from interface: `GraphTraversal`
      Projects the current object in the stream into a `Map` that is keyed by the provided labels.
      Specified by:
        `project` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `ProjectStep`
      See Also:
        Reference Documentation - Project Step

    - #### select

          default <E2> CredentialTraversal<S,Map<String,E2>> select(Pop pop,
                                                                    String selectKey1,
                                                                    String selectKey2,
                                                                    String... otherSelectKeys)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to a `Map` projection of sideEffect values, map values, and/or path values.
      Specified by:
        `select` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the type of the objects projected
      Parameters:
        `pop` - if there are multiple objects referenced in the path, the `Pop` to use.
        `selectKey1` - the first key to project
        `selectKey2` - the second key to project
        `otherSelectKeys` - the third+ keys to project
      Returns:
        the traversal with an appended `SelectStep`.
      See Also:
        Reference Documentation - Select Step

    - #### select

          default <E2> CredentialTraversal<S,Map<String,E2>> select(String selectKey1,
                                                                    String selectKey2,
                                                                    String... otherSelectKeys)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to a `Map` projection of sideEffect values, map values, and/or path values.
      Specified by:
        `select` in interface `GraphTraversal<S,E>`
      Type Parameters:
        `E2` - the type of the objects projected
      Parameters:
        `selectKey1` - the first key to project
        `selectKey2` - the second key to project
        `otherSelectKeys` - the third+ keys to project
      Returns:
        the traversal with an appended `SelectStep`.
      See Also:
        Reference Documentation - Select Step

    - #### select

          default <E2> CredentialTraversal<S,E2> select(Pop pop,
                                                        String selectKey)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to the object specified by the `selectKey` and apply the `Pop` operation to it.
      Specified by:
        `select` in interface `GraphTraversal<S,E>`
        `selectKey` - the key to project
      Returns:
        the traversal with an appended `SelectStep`.
      See Also:
        Reference Documentation - Select Step

    - #### select

          default <E2> CredentialTraversal<S,E2> select(String selectKey)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to the object specified by the `selectKey`. Note that unlike other uses of `select` where there are multiple keys, this use of `select` with a single key does not produce a `Map`.
      Specified by:
        `select` in interface `GraphTraversal<S,E>`
      Parameters:
        `selectKey` - the key to project
      Returns:
        the traversal with an appended `SelectStep`.
      See Also:
        Reference Documentation - Select Step

    - #### select

          default <E2> CredentialTraversal<S,E2> select(Pop pop,
                                                        Traversal<S,E2> keyTraversal)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to the object specified by the key returned by the `keyTraversal` and apply the `Pop` operation to it.
      Specified by:
        `select` in interface `GraphTraversal<S,E>`
        `keyTraversal` - the traversal expression that selects the key to project
      Returns:
        the traversal with an appended `SelectStep`.
      See Also:
        Reference Documentation - Select Step

    - #### select

          default <E2> CredentialTraversal<S,E2> select(Traversal<S,E2> keyTraversal)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to the object specified by the key returned by the `keyTraversal`. Note that unlike other uses of `select` where there are multiple keys, this use of `select` with a traversal does not produce a `Map`.
      Specified by:
        `select` in interface `GraphTraversal<S,E>`
      Parameters:
        `keyTraversal` - the traversal expression that selects the key to project
      Returns:
        the traversal with an appended `TraversalSelectStep`.
      See Also:
        Reference Documentation - Select Step

    - #### select

          default <E2> CredentialTraversal<S,Collection<E2>> select(Column column)

      Description copied from interface: `GraphTraversal`
      A version of `select` that allows for the extraction of a `Column` from objects in the traversal.
      Specified by:
        `select` in interface `GraphTraversal<S,E>`
      Parameters:
        `column` - the column to extract
      Returns:
        the traversal with an appended `TraversalMapStep`
      See Also:
        Reference Documentation - Select Step

    - #### unfold

          default <E2> CredentialTraversal<S,E2> unfold()

      Description copied from interface: `GraphTraversal`
      Unrolls a `Iterator`, `Iterable` or `Map` into a linear form or simply emits the object if it is not one of those types.
      Specified by:
        `unfold` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `UnfoldStep`
      See Also:
        Reference Documentation - Unfold Step

    - #### fold

          default CredentialTraversal<S,List<E>> fold()

      Description copied from interface: `GraphTraversal`
      Rolls up objects in the stream into an aggregate list.
      Specified by:
        `fold` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `FoldStep`
      See Also:
        Reference Documentation - Fold Step

    - #### fold

          default <E2> CredentialTraversal<S,E2> fold(E2 seed,
                                                      BiFunction<E2,E,E2> foldFunction)

      Description copied from interface: `GraphTraversal`
      Rolls up objects in the stream into an aggregate value as defined by a `seed` and `BiFunction`.
      Specified by:
        `fold` in interface `GraphTraversal<S,E>`
      Parameters:
        `seed` - the value to provide as the first argument to the `foldFunction`
        `foldFunction` - the function to fold by where the first argument is the `seed` or the value returned from subsequent class and the second argument is the value from the stream
      Returns:
        the traversal with an appended `FoldStep`
      See Also:
        Reference Documentation - Fold Step

    - #### count

          default CredentialTraversal<S,Long> count()

      Description copied from interface: `GraphTraversal`
      Map the traversal stream to its reduction as a sum of the `Traverser.bulk()` values (i.e. count the number of traversers up to this point).
      Specified by:
        `count` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `CountGlobalStep`.
      See Also:
        Reference Documentation - Count Step

    - #### count

          default CredentialTraversal<S,Long> count(Scope scope)

      Description copied from interface: `GraphTraversal`
      Map the traversal stream to its reduction as a sum of the `Traverser.bulk()` values given the specified `Scope` (i.e. count the number of traversers up to this point).
      Specified by:
        `count` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `CountGlobalStep` or `CountLocalStep` depending on the `Scope`
      See Also:
        Reference Documentation - Count Step

    - #### sum

          default <E2 extends Number> CredentialTraversal<S,E2> sum()

      Description copied from interface: `GraphTraversal`
      Map the traversal stream to its reduction as a sum of the `Traverser.get()` values multiplied by their `Traverser.bulk()` (i.e. sum the traverser values up to this point).
      Specified by:
        `sum` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `SumGlobalStep`.
      See Also:
        Reference Documentation - Sum Step

    - #### sum

          default <E2 extends Number> CredentialTraversal<S,E2> sum(Scope scope)

      Description copied from interface: `GraphTraversal`
      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. sum the traverser values up to this point).
      Specified by:
        `sum` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `SumGlobalStep` or `SumLocalStep` depending on the `Scope`.
      See Also:
        Reference Documentation - Sum Step

    - #### max

          default <E2 extends Comparable> CredentialTraversal<S,E2> max()

      Description copied from interface: `GraphTraversal`
      Determines the largest value in the stream.
      Specified by:
        `max` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `MaxGlobalStep`.
      See Also:
        Reference Documentation - Max Step

    - #### max

          default <E2 extends Comparable> CredentialTraversal<S,E2> max(Scope scope)

      Description copied from interface: `GraphTraversal`
      Determines the largest value in the stream given the `Scope`.
      Specified by:
        `max` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `MaxGlobalStep` or `MaxLocalStep` depending on the `Scope`
      See Also:
        Reference Documentation - Max Step

    - #### min

          default <E2 extends Comparable> CredentialTraversal<S,E2> min()

      Description copied from interface: `GraphTraversal`
      Determines the smallest value in the stream.
      Specified by:
        `min` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `MinGlobalStep`.
      See Also:
        Reference Documentation - Min Step

    - #### min

          default <E2 extends Comparable> CredentialTraversal<S,E2> min(Scope scope)

      Description copied from interface: `GraphTraversal`
      Determines the smallest value in the stream given the `Scope`.
      Specified by:
        `min` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `MinGlobalStep` or `MinLocalStep` depending on the `Scope`
      See Also:
        Reference Documentation - Min Step

    - #### mean

          default <E2 extends Number> CredentialTraversal<S,E2> mean()

      Description copied from interface: `GraphTraversal`
      Determines the mean value in the stream.
      Specified by:
        `mean` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `MeanGlobalStep`.
      See Also:
        Reference Documentation - Mean Step

    - #### mean

          default <E2 extends Number> CredentialTraversal<S,E2> mean(Scope scope)

      Description copied from interface: `GraphTraversal`
      Determines the mean value in the stream given the `Scope`.
      Specified by:
        `mean` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `MeanGlobalStep` or `MeanLocalStep` depending on the `Scope`
      See Also:
        Reference Documentation - Mean Step

    - #### group

          default <K,V> CredentialTraversal<S,Map<K,V>> group()

      Description copied from interface: `GraphTraversal`
      Organize objects in the stream into a `Map`. Calls to `group()` are typically accompanied with `GraphTraversal.by()` modulators which help specify how the grouping should occur.
      Specified by:
        `group` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `GroupStep`.
      See Also:
        Reference Documentation - Group Step

    - #### groupCount

          default <K> CredentialTraversal<S,Map<K,Long>> groupCount()

      Description copied from interface: `GraphTraversal`
      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.
      Specified by:
        `groupCount` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `GroupCountStep`.
      See Also:
        Reference Documentation - GroupCount Step

    - #### tree

          default CredentialTraversal<S,Tree> tree()

      Description copied from interface: `GraphTraversal`
      Aggregates the emanating paths into a `Tree` data structure.
      Specified by:
        `tree` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `TreeStep`
      See Also:
        Reference Documentation - Tree Step

    - #### addV

          default CredentialTraversal<S,Vertex> addV(String vertexLabel)

      Description copied from interface: `GraphTraversal`
      Adds a `Vertex`.
      Specified by:
        `addV` in interface `GraphTraversal<S,E>`
      Parameters:
        `vertexLabel` - the label of the `Vertex` to add
      Returns:
        the traversal with the `AddVertexStep` added
      See Also:
        Reference Documentation - AddVertex Step

    - #### addV

          default CredentialTraversal<S,Vertex> addV(Traversal<?,String> vertexLabelTraversal)

      Description copied from interface: `GraphTraversal`
      Adds a `Vertex` with a vertex label determined by a `Traversal`.
      Specified by:
        `addV` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the `AddVertexStep` added
      See Also:
        Reference Documentation - AddVertex Step

    - #### addV

          default CredentialTraversal<S,Vertex> addV()

      Description copied from interface: `GraphTraversal`
      Adds a `Vertex` with a default vertex label.
      Specified by:
        `addV` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the `AddVertexStep` added
      See Also:
        Reference Documentation - AddVertex Step

    - #### addE

          default CredentialTraversal<S,Edge> addE(String edgeLabel)

      Description copied from interface: `GraphTraversal`
      Adds an `Edge` with the specified edge label.
      Specified by:
        `addE` in interface `GraphTraversal<S,E>`
      Parameters:
        `edgeLabel` - the label of the newly added edge
      Returns:
        the traversal with the `AddEdgeStep` added
      See Also:
        Reference Documentation - AddEdge Step

    - #### addE

          default CredentialTraversal<S,Edge> addE(Traversal<?,String> edgeLabelTraversal)

      Description copied from interface: `GraphTraversal`
      Adds a `Edge` with an edge label determined by a `Traversal`.
      Specified by:
        `addE` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the `AddEdgeStep` added
      See Also:
        Reference Documentation - AddEdge Step

    - #### to

          default CredentialTraversal<S,E> to(String toStepLabel)

      Description copied from interface: `GraphTraversal`
      Provide `to()`-modulation to respective steps.
      Specified by:
        `to` in interface `GraphTraversal<S,E>`
      Parameters:
        `toStepLabel` - the step label to modulate to.
      Returns:
        the traversal with the modified `FromToModulating` step.
      See Also:
        Reference Documentation - To Step

    - #### from

          default CredentialTraversal<S,E> from(String fromStepLabel)

      Description copied from interface: `GraphTraversal`
      Provide `from()`-modulation to respective steps.
      Specified by:
        `from` in interface `GraphTraversal<S,E>`
      Parameters:
        `fromStepLabel` - the step label to modulate to.
      Returns:
        the traversal with the modified `FromToModulating` step.
      See Also:
        Reference Documentation - From Step

    - #### to

          default CredentialTraversal<S,E> to(Traversal<?,Vertex> toVertex)

      Description copied from interface: `GraphTraversal`
      When used as a modifier to `GraphTraversal.addE(String)` this method specifies the traversal to use for selecting the incoming vertex of the newly added `Edge`.
      Specified by:
        `to` in interface `GraphTraversal<S,E>`
      Parameters:
        `toVertex` - the traversal for selecting the incoming vertex
      Returns:
        the traversal with the modified `AddEdgeStep`
      See Also:
        Reference Documentation - From Step

    - #### from

          default CredentialTraversal<S,E> from(Traversal<?,Vertex> fromVertex)

      Description copied from interface: `GraphTraversal`
      When used as a modifier to `GraphTraversal.addE(String)` this method specifies the traversal to use for selecting the outgoing vertex of the newly added `Edge`.
      Specified by:
        `from` in interface `GraphTraversal<S,E>`
      Parameters:
        `fromVertex` - the traversal for selecting the outgoing vertex
      Returns:
        the traversal with the modified `AddEdgeStep`
      See Also:
        Reference Documentation - From Step

    - #### to

          default CredentialTraversal<S,E> to(Vertex toVertex)

      Description copied from interface: `GraphTraversal`
      When used as a modifier to `GraphTraversal.addE(String)` this method specifies the traversal to use for selecting the incoming vertex of the newly added `Edge`.
      Specified by:
        `to` in interface `GraphTraversal<S,E>`
      Parameters:
        `toVertex` - the vertex for selecting the incoming vertex
      Returns:
        the traversal with the modified `AddEdgeStep`
      See Also:
        Reference Documentation - From Step

    - #### from

          default CredentialTraversal<S,E> from(Vertex fromVertex)

      Description copied from interface: `GraphTraversal`
      When used as a modifier to `GraphTraversal.addE(String)` this method specifies the traversal to use for selecting the outgoing vertex of the newly added `Edge`.
      Specified by:
        `from` in interface `GraphTraversal<S,E>`
      Parameters:
        `fromVertex` - the vertex for selecting the outgoing vertex
      Returns:
        the traversal with the modified `AddEdgeStep`
      See Also:
        Reference Documentation - From Step

    - #### math

          default CredentialTraversal<S,Double> math(String expression)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to a `Double` according to the mathematical expression provided in the argument.
      Specified by:
        `math` in interface `GraphTraversal<S,E>`
      Parameters:
        `expression` - the mathematical expression with variables refering to scope variables.
      Returns:
        the traversal with the `MathStep` added.

    - #### filter

          default CredentialTraversal<S,E> filter(Predicate<Traverser<E>> predicate)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to either `true` or `false`, where `false` will not pass the traverser to the next step.
      Specified by:
        `filter` in interface `GraphTraversal<S,E>`
      Parameters:
        `predicate` - the filter function to apply
      Returns:
        the traversal with the `LambdaFilterStep` added
      See Also:
        Reference Documentation - General Steps

    - #### filter

          default CredentialTraversal<S,E> filter(Traversal<?,?> filterTraversal)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to either `true` or `false`, where `false` will not pass the traverser to the next step.
      Specified by:
        `filter` in interface `GraphTraversal<S,E>`
      Parameters:
        `filterTraversal` - the filter traversal to apply
      Returns:
        the traversal with the `TraversalFilterStep` added
      See Also:
        Reference Documentation - General Steps

    - #### or

          default CredentialTraversal<S,E> or(Traversal<?,?>... orTraversals)

      Description copied from interface: `GraphTraversal`
      Ensures that at least one of the provided traversals yield a result.
      Specified by:
        `or` in interface `GraphTraversal<S,E>`
      Parameters:
        `orTraversals` - filter traversals where at least one must be satisfied
      Returns:
        the traversal with an appended `OrStep`
      See Also:
        Reference Documentation - Or Step

    - #### and

          default CredentialTraversal<S,E> and(Traversal<?,?>... andTraversals)

      Description copied from interface: `GraphTraversal`
      Ensures that all of the provided traversals yield a result.
      Specified by:
        `and` in interface `GraphTraversal<S,E>`
      Parameters:
        `andTraversals` - filter traversals that must be satisfied
      Returns:
        the traversal with an appended `AndStep`
      See Also:
        Reference Documentation - And Step

    - #### inject

          default CredentialTraversal<S,E> inject(E... injections)

      Description copied from interface: `GraphTraversal`
      Provides a way to add arbitrary objects to a traversal stream.
      Specified by:
        `inject` in interface `GraphTraversal<S,E>`
      Parameters:
        `injections` - the objects to add to the stream
      Returns:
        the traversal with an appended `InjectStep`
      See Also:
        Reference Documentation - Inject Step

    - #### dedup

          default CredentialTraversal<S,E> dedup(Scope scope,
                                                 String... dedupLabels)

      Description copied from interface: `GraphTraversal`
      Remove all duplicates in the traversal stream up to this point.
      Specified by:
        `dedup` in interface `GraphTraversal<S,E>`
      Parameters:
        `scope` - whether the deduplication is on the stream (global) or the current object (local).
        `dedupLabels` - if labels are provided, then the scope labels determine de-duplication. No labels implies current object.
      Returns:
        the traversal with an appended `DedupGlobalStep` or `DedupLocalStep` depending on `scope`
      See Also:
        Reference Documentation - Dedup Step

    - #### dedup

          default CredentialTraversal<S,E> dedup(String... dedupLabels)

      Description copied from interface: `GraphTraversal`
      Remove all duplicates in the traversal stream up to this point.
      Specified by:
        `dedup` in interface `GraphTraversal<S,E>`
      Parameters:
        `dedupLabels` - if labels are provided, then the scoped object's labels determine de-duplication. No labels implies current object.
      Returns:
        the traversal with an appended `DedupGlobalStep`.
      See Also:
        Reference Documentation - Dedup Step

    - #### where

          default CredentialTraversal<S,E> where(String startKey,
                                                 P<String> predicate)

      Description copied from interface: `GraphTraversal`
      Filters the current object based on the object itself or the path history.
      Specified by:
        `where` in interface `GraphTraversal<S,E>`
      Parameters:
        `startKey` - the key containing the object to filter
        `predicate` - the filter to apply
      Returns:
        the traversal with an appended `WherePredicateStep`
      See Also:
        Reference Documentation - Where Step, Reference Documentation - Where with Match, Reference Documentation - Where with Select

    - #### where

          default CredentialTraversal<S,E> where(P<String> predicate)

      Description copied from interface: `GraphTraversal`
      Filters the current object based on the object itself or the path history.
      Specified by:
        `where` in interface `GraphTraversal<S,E>`
      Parameters:
        `predicate` - the filter to apply
      Returns:
        the traversal with an appended `WherePredicateStep`
      See Also:
        Reference Documentation - Where Step, Reference Documentation - Where with Match, Reference Documentation - Where with Select

    - #### where

          default CredentialTraversal<S,E> where(Traversal<?,?> whereTraversal)

      Description copied from interface: `GraphTraversal`
      Filters the current object based on the object itself or the path history.
      Specified by:
        `where` in interface `GraphTraversal<S,E>`
      Parameters:
        `whereTraversal` - the filter to apply
      Returns:
        the traversal with an appended `WherePredicateStep`
      See Also:
        Reference Documentation - Where Step, Reference Documentation - Where with Match, Reference Documentation - Where with Select

    - #### has

          default CredentialTraversal<S,E> has(String propertyKey,
                                               P<?> predicate)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their properties.
      Specified by:
        `has` in interface `GraphTraversal<S,E>`
      Parameters:
        `propertyKey` - the key of the property to filter on
        `predicate` - the filter to apply to the key's value
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### has

          default CredentialTraversal<S,E> has(T accessor,
                                               P<?> predicate)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their properties.
      Specified by:
        `has` in interface `GraphTraversal<S,E>`
      Parameters:
        `accessor` - the `T` accessor of the property to filter on
        `predicate` - the filter to apply to the key's value
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### has

          default CredentialTraversal<S,E> has(String propertyKey,
                                               Object value)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their properties.
      Specified by:
        `has` in interface `GraphTraversal<S,E>`
      Parameters:
        `propertyKey` - the key of the property to filter on
        `value` - the value to compare the property value to for equality
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### has

          default CredentialTraversal<S,E> has(T accessor,
                                               Object value)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their properties.
      Specified by:
        `has` in interface `GraphTraversal<S,E>`
      Parameters:
        `accessor` - the `T` accessor of the property to filter on
        `value` - the value to compare the accessor value to for equality
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### has

          default CredentialTraversal<S,E> has(String label,
                                               String propertyKey,
                                               P<?> predicate)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their properties.
      Specified by:
        `has` in interface `GraphTraversal<S,E>`
      Parameters:
        `label` - the label of the `Element`
        `propertyKey` - the key of the property to filter on
        `predicate` - the filter to apply to the key's value
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### has

          default CredentialTraversal<S,E> has(String label,
                                               String propertyKey,
                                               Object value)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their properties.
      Specified by:
        `has` in interface `GraphTraversal<S,E>`
      Parameters:
        `label` - the label of the `Element`
        `propertyKey` - the key of the property to filter on
        `value` - the value to compare the accessor value to for equality
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### has

          default CredentialTraversal<S,E> has(T accessor,
                                               Traversal<?,?> propertyTraversal)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their value of `T` where only `T.id` and `T.label` are supported.
      Specified by:
        `has` in interface `GraphTraversal<S,E>`
      Parameters:
        `accessor` - the `T` accessor of the property to filter on
        `propertyTraversal` - the traversal to filter the accessor value by
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### has

          default CredentialTraversal<S,E> has(String propertyKey,
                                               Traversal<?,?> propertyTraversal)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on the value of the specified property key.
      Specified by:
        `has` in interface `GraphTraversal<S,E>`
      Parameters:
        `propertyKey` - the key of the property to filter on
        `propertyTraversal` - the traversal to filter the property value by
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### has

          default CredentialTraversal<S,E> has(String propertyKey)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on the existence of properties.
      Specified by:
        `has` in interface `GraphTraversal<S,E>`
      Parameters:
        `propertyKey` - the key of the property to filter on for existence
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### hasNot

          default CredentialTraversal<S,E> hasNot(String propertyKey)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on the non-existence of properties.
      Specified by:
        `hasNot` in interface `GraphTraversal<S,E>`
      Parameters:
        `propertyKey` - the key of the property to filter on for existence
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### hasLabel

          default CredentialTraversal<S,E> hasLabel(String label,
                                                    String... otherLabels)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their label.
      Specified by:
        `hasLabel` in interface `GraphTraversal<S,E>`
      Parameters:
        `label` - the label of the `Element`
        `otherLabels` - additional labels of the `Element`
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### hasLabel

          default CredentialTraversal<S,E> hasLabel(P<String> predicate)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their label. Note that calling this step with `null` is the same as calling `GraphTraversal.hasLabel(String, String...)` with a single `null`.
      Specified by:
        `hasLabel` in interface `GraphTraversal<S,E>`
      Parameters:
        `predicate` - the filter to apply to the label of the `Element`
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### hasId

          default CredentialTraversal<S,E> hasId(Object id,
                                                 Object... otherIds)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their identifier.
      Specified by:
        `hasId` in interface `GraphTraversal<S,E>`
      Parameters:
        `id` - the identifier of the `Element`
        `otherIds` - additional identifiers of the `Element`
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### hasId

          default CredentialTraversal<S,E> hasId(P<Object> predicate)

      Description copied from interface: `GraphTraversal`
      Filters vertices, edges and vertex properties based on their identifier.
      Specified by:
        `hasId` in interface `GraphTraversal<S,E>`
      Parameters:
        `predicate` - the filter to apply to the identifier of the `Element`
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### hasKey

          default CredentialTraversal<S,E> hasKey(String label,
                                                  String... otherLabels)

      Description copied from interface: `GraphTraversal`
      Filters `Property` objects based on their key. It is not meant to test key existence on an `Edge` or a `Vertex`. In that case, prefer `GraphTraversal.has(String)`.
      Specified by:
        `hasKey` in interface `GraphTraversal<S,E>`
      Parameters:
        `label` - the key of the `Property`
        `otherLabels` - additional key of the `Property`
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### hasKey

          default CredentialTraversal<S,E> hasKey(P<String> predicate)

      Description copied from interface: `GraphTraversal`
      Filters `Property` objects based on their key. It is not meant to test key existence on an `Edge` or a `Vertex`. In that case, prefer `GraphTraversal.has(String)`. Note that calling this step with `null` is the same as calling `GraphTraversal.hasKey(String, String...)` with a single `null`.
      Specified by:
        `hasKey` in interface `GraphTraversal<S,E>`
      Parameters:
        `predicate` - the filter to apply to the key of the `Property`
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### hasValue

          default CredentialTraversal<S,E> hasValue(Object value,
                                                    Object... otherValues)

      Description copied from interface: `GraphTraversal`
      Filters `Property` objects based on their value.
      Specified by:
        `hasValue` in interface `GraphTraversal<S,E>`
      Parameters:
        `value` - the value of the `Element`
        `otherValues` - additional values of the `Element`
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### hasValue

          default CredentialTraversal<S,E> hasValue(P<Object> predicate)

      Description copied from interface: `GraphTraversal`
      Filters `Property` objects based on their value.Note that calling this step with `null` is the same as calling `GraphTraversal.hasValue(Object, Object...)` with a single `null`.
      Specified by:
        `hasValue` in interface `GraphTraversal<S,E>`
      Parameters:
        `predicate` - the filter to apply to the value of the `Element`
      Returns:
        the traversal with an appended `HasStep`
      See Also:
        Reference Documentation - Has Step

    - #### is

          default CredentialTraversal<S,E> is(P<E> predicate)

      Description copied from interface: `GraphTraversal`
      Filters `E` object values given the provided `predicate`.
      Specified by:
        `is` in interface `GraphTraversal<S,E>`
      Parameters:
        `predicate` - the filter to apply
      Returns:
        the traversal with an appended `IsStep`
      See Also:
        Reference Documentation - Is Step

    - #### is

          default CredentialTraversal<S,E> is(Object value)

      Description copied from interface: `GraphTraversal`
      Filter the `E` object if it is not `P.eq(V)` to the provided value.
      Specified by:
        `is` in interface `GraphTraversal<S,E>`
      Parameters:
        `value` - the value that the object must equal.
      Returns:
        the traversal with an appended `IsStep`.
      See Also:
        Reference Documentation - Is Step

    - #### not

          default CredentialTraversal<S,E> not(Traversal<?,?> notTraversal)

      Description copied from interface: `GraphTraversal`
      Removes objects from the traversal stream when the traversal provided as an argument does not return any objects.
      Specified by:
        `not` in interface `GraphTraversal<S,E>`
      Parameters:
        `notTraversal` - the traversal to filter by.
      Returns:
        the traversal with an appended `NotStep`.
      See Also:
        Reference Documentation - Not Step

    - #### coin

          default CredentialTraversal<S,E> coin(double probability)

      Description copied from interface: `GraphTraversal`
      Filter the `E` object given a biased coin toss.
      Specified by:
        `coin` in interface `GraphTraversal<S,E>`
      Parameters:
        `probability` - the probability that the object will pass through
      Returns:
        the traversal with an appended `CoinStep`.
      See Also:
        Reference Documentation - Coin Step

    - #### range

          default CredentialTraversal<S,E> range(long low,
                                                 long arg1)

      Description copied from interface: `GraphTraversal`
      Filter the objects in the traversal by the number of them to pass through the stream. Those before the value of `low` do not pass through and those that exceed the value of `high` will end the iteration.
      Specified by:
        `range` in interface `GraphTraversal<S,E>`
      Parameters:
        `low` - the number at which to start allowing objects through the stream
        `arg1` - the number at which to end the stream - use `-1` to emit all remaining objects
      Returns:
        the traversal with an appended `RangeGlobalStep`
      See Also:
        Reference Documentation - Range Step

    - #### range

          default <E2> CredentialTraversal<S,E2> range(Scope scope,
                                                       long low,
                                                       long arg2)

      Description copied from interface: `GraphTraversal`
      Filter the objects in the traversal by the number of them to pass through the stream as constrained by the `Scope`. Those before the value of `low` do not pass through and those that exceed the value of `high` will end the iteration.
      Specified by:
        `range` in interface `GraphTraversal<S,E>`
      Parameters:
        `scope` - the scope of how to apply the `range`
        `low` - the number at which to start allowing objects through the stream
        `arg2` - the number at which to end the stream - use `-1` to emit all remaining objects
      Returns:
        the traversal with an appended `RangeGlobalStep` or `RangeLocalStep` depending on `scope`
      See Also:
        Reference Documentation - Range Step

    - #### limit

          default CredentialTraversal<S,E> limit(long limit)

      Description copied from interface: `GraphTraversal`
      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.
      Specified by:
        `limit` in interface `GraphTraversal<S,E>`
      Parameters:
        `limit` - the number at which to end the stream
      Returns:
        the traversal with an appended `RangeGlobalStep`
      See Also:
        Reference Documentation - Limit Step

    - #### limit

          default <E2> CredentialTraversal<S,E2> limit(Scope scope,
                                                       long limit)

      Description copied from interface: `GraphTraversal`
      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.
      Specified by:
        `limit` in interface `GraphTraversal<S,E>`
      Parameters:
        `scope` - the scope of how to apply the `limit`
        `limit` - the number at which to end the stream
      Returns:
        the traversal with an appended `RangeGlobalStep` or `RangeLocalStep` depending on `scope`
      See Also:
        Reference Documentation - Limit Step

    - #### tail

          default CredentialTraversal<S,E> tail()

      Description copied from interface: `GraphTraversal`
      Filters the objects in the traversal emitted as being last objects in the stream. In this case, only the last object will be returned.
      Specified by:
        `tail` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `TailGlobalStep`
      See Also:
        Reference Documentation - Tail Step

    - #### tail

          default CredentialTraversal<S,E> tail(long limit)

      Description copied from interface: `GraphTraversal`
      Filters the objects in the traversal emitted as being last objects in the stream. In this case, only the last `n` objects will be returned as defined by the `limit`.
      Specified by:
        `tail` in interface `GraphTraversal<S,E>`
      Parameters:
        `limit` - the number at which to end the stream
      Returns:
        the traversal with an appended `TailGlobalStep`
      See Also:
        Reference Documentation - Tail Step

    - #### tail

          default <E2> CredentialTraversal<S,E2> tail(Scope scope)

      Description copied from interface: `GraphTraversal`
      Filters the objects in the traversal emitted as being last objects in the stream given the `Scope`. In this case, only the last object in the stream will be returned.
      Specified by:
        `tail` in interface `GraphTraversal<S,E>`
      Parameters:
        `scope` - the scope of how to apply the `tail`
      Returns:
        the traversal with an appended `TailGlobalStep` or `TailLocalStep` depending on `scope`
      See Also:
        Reference Documentation - Tail Step

    - #### tail

          default <E2> CredentialTraversal<S,E2> tail(Scope scope,
                                                      long limit)

      Description copied from interface: `GraphTraversal`
      Filters the objects in the traversal emitted as being last objects in the stream given the `Scope`. In this case, only the last `n` objects will be returned as defined by the `limit`.
      Specified by:
        `tail` in interface `GraphTraversal<S,E>`
      Parameters:
        `scope` - the scope of how to apply the `tail`
        `limit` - the number at which to end the stream
      Returns:
        the traversal with an appended `TailGlobalStep` or `TailLocalStep` depending on `scope`
      See Also:
        Reference Documentation - Tail Step

    - #### skip

          default CredentialTraversal<S,E> skip(long skip)

      Description copied from interface: `GraphTraversal`
      Filters out the first `n` objects in the traversal.
      Specified by:
        `skip` in interface `GraphTraversal<S,E>`
      Parameters:
        `skip` - the number of objects to skip
      Returns:
        the traversal with an appended `RangeGlobalStep`
      See Also:
        Reference Documentation - Skip Step

    - #### skip

          default <E2> CredentialTraversal<S,E2> skip(Scope scope,
                                                      long skip)

      Description copied from interface: `GraphTraversal`
      Filters out the first `n` objects in the traversal.
      Specified by:
        `skip` in interface `GraphTraversal<S,E>`
      Parameters:
        `scope` - the scope of how to apply the `tail`
        `skip` - the number of objects to skip
      Returns:
        the traversal with an appended `RangeGlobalStep` or `RangeLocalStep` depending on `scope`
      See Also:
        Reference Documentation - Skip Step

    - #### timeLimit

          default CredentialTraversal<S,E> timeLimit(long timeLimit)

      Description copied from interface: `GraphTraversal`
      Once the first `Traverser` hits this step, a count down is started. Once the time limit is up, all remaining traversers are filtered out.
      Specified by:
        `timeLimit` in interface `GraphTraversal<S,E>`
      Parameters:
        `timeLimit` - the count down time
      Returns:
        the traversal with an appended `TimeLimitStep`
      See Also:
        Reference Documentation - TimeLimit Step

    - #### simplePath

          default CredentialTraversal<S,E> simplePath()

      Description copied from interface: `GraphTraversal`
      Filter the `E` object if its `Traverser.path()` is not `Path.isSimple()`.
      Specified by:
        `simplePath` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `PathFilterStep`.
      See Also:
        Reference Documentation - SimplePath Step

    - #### cyclicPath

          default CredentialTraversal<S,E> cyclicPath()

      Description copied from interface: `GraphTraversal`
      Filter the `E` object if its `Traverser.path()` is `Path.isSimple()`.
      Specified by:
        `cyclicPath` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `PathFilterStep`.
      See Also:
        Reference Documentation - CyclicPath Step

    - #### sample

          default CredentialTraversal<S,E> sample(int amountToSample)

      Description copied from interface: `GraphTraversal`
      Allow some specified number of objects to pass through the stream.
      Specified by:
        `sample` in interface `GraphTraversal<S,E>`
      Parameters:
        `amountToSample` - the number of objects to allow
      Returns:
        the traversal with an appended `SampleGlobalStep`
      See Also:
        Reference Documentation - Sample Step

    - #### sample

          default CredentialTraversal<S,E> sample(Scope scope,
                                                  int amountToSample)

      Description copied from interface: `GraphTraversal`
      Allow some specified number of objects to pass through the stream.
      Specified by:
        `sample` in interface `GraphTraversal<S,E>`
      Parameters:
        `scope` - the scope of how to apply the `sample`
        `amountToSample` - the number of objects to allow
      Returns:
        the traversal with an appended `SampleGlobalStep` or `SampleLocalStep` depending on the `scope`
      See Also:
        Reference Documentation - Sample Step

    - #### drop

          default CredentialTraversal<S,E> drop()

      Description copied from interface: `GraphTraversal`
      Removes elements and properties from the graph. This step is not a terminating, in the sense that it does not automatically iterate the traversal. It is therefore necessary to do some form of iteration for the removal to actually take place. In most cases, iteration is best accomplished with `g.V().drop().iterate()`.
      Specified by:
        `drop` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the `DropStep` added
      See Also:
        Reference Documentation - Drop Step

    - #### sideEffect

          default CredentialTraversal<S,E> sideEffect(Consumer<Traverser<E>> consumer)

      Description copied from interface: `GraphTraversal`
      Perform some operation on the `Traverser` and pass it to the next step unmodified.
      Specified by:
        `sideEffect` in interface `GraphTraversal<S,E>`
      Parameters:
        `consumer` - the operation to perform at this step in relation to the `Traverser`
      Returns:
        the traversal with an appended `LambdaSideEffectStep`
      See Also:
        Reference Documentation - General Steps

    - #### sideEffect

          default CredentialTraversal<S,E> sideEffect(Traversal<?,?> sideEffectTraversal)

      Description copied from interface: `GraphTraversal`
      Perform some operation on the `Traverser` and pass it to the next step unmodified.
      Specified by:
        `sideEffect` in interface `GraphTraversal<S,E>`
      Parameters:
        `sideEffectTraversal` - the operation to perform at this step in relation to the `Traverser`
      Returns:
        the traversal with an appended `TraversalSideEffectStep`
      See Also:
        Reference Documentation - General Steps

    - #### cap

          default <E2> CredentialTraversal<S,E2> cap(String sideEffectKey,
                                                     String... sideEffectKeys)

      Description copied from interface: `GraphTraversal`
      Iterates the traversal up to the itself and emits the side-effect referenced by the key. If multiple keys are supplied then the side-effects are emitted as a `Map`.
      Specified by:
        `cap` in interface `GraphTraversal<S,E>`
      Parameters:
        `sideEffectKey` - the side-effect to emit
        `sideEffectKeys` - other side-effects to emit
      Returns:
        the traversal with an appended `SideEffectCapStep`
      See Also:
        Reference Documentation - Cap Step

    - #### subgraph

          default CredentialTraversal<S,Edge> subgraph(String sideEffectKey)

      Description copied from interface: `GraphTraversal`
      Extracts a portion of the graph being traversed into a `Graph` object held in the specified side-effect key.
      Specified by:
        `subgraph` in interface `GraphTraversal<S,E>`
      Parameters:
        `sideEffectKey` - the name of the side-effect key that will hold the subgraph
      Returns:
        the traversal with an appended `SubgraphStep`
      See Also:
        Reference Documentation - Subgraph Step

    - #### aggregate

          default CredentialTraversal<S,E> aggregate(String sideEffectKey)

      Description copied from interface: `GraphTraversal`
      Eagerly collects objects up to this step into a side-effect. Same as calling `GraphTraversal.aggregate(Scope, String)` with a `Scope.local`.
      Specified by:
        `aggregate` in interface `GraphTraversal<S,E>`
      Parameters:
        `sideEffectKey` - the name of the side-effect key that will hold the aggregated objects
      Returns:
        the traversal with an appended `AggregateGlobalStep`
      See Also:
        Reference Documentation - Aggregate Step

    - #### aggregate

          default CredentialTraversal<S,E> aggregate(Scope scope,
                                                     String sideEffectKey)

      Description copied from interface: `GraphTraversal`
      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.
      Specified by:
        `aggregate` in interface `GraphTraversal<S,E>`
        `sideEffectKey` - the name of the side-effect key that will hold the aggregated objects
      Returns:
        the traversal with an appended `AggregateGlobalStep`
      See Also:
        Reference Documentation - Aggregate Step

    - #### group

          default CredentialTraversal<S,E> group(String sideEffectKey)

      Description copied from interface: `GraphTraversal`
      Organize objects in the stream into a `Map`. Calls to `group()` are typically accompanied with `GraphTraversal.by()` modulators which help specify how the grouping should occur.
      Specified by:
        `group` in interface `GraphTraversal<S,E>`
      Parameters:
        `sideEffectKey` - the name of the side-effect key that will hold the aggregated grouping
      Returns:
        the traversal with an appended `GroupStep`.
      See Also:
        Reference Documentation - Group Step

    - #### groupCount

          default CredentialTraversal<S,E> groupCount(String sideEffectKey)

      Description copied from interface: `GraphTraversal`
      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.
      Specified by:
        `groupCount` in interface `GraphTraversal<S,E>`
      Parameters:
        `sideEffectKey` - the name of the side-effect key that will hold the aggregated grouping
      Returns:
        the traversal with an appended `GroupCountStep`.
      See Also:
        Reference Documentation - GroupCount Step

    - #### tree

          default CredentialTraversal<S,E> tree(String sideEffectKey)

      Description copied from interface: `GraphTraversal`
      Aggregates the emanating paths into a `Tree` data structure.
      Specified by:
        `tree` in interface `GraphTraversal<S,E>`
      Parameters:
        `sideEffectKey` - the name of the side-effect key that will hold the tree
      Returns:
        the traversal with an appended `TreeStep`
      See Also:
        Reference Documentation - Tree Step

    - #### sack

          default <V,U> CredentialTraversal<S,E> sack(BiFunction<V,U,V> sackOperator)

      Description copied from interface: `GraphTraversal`
      Map the `Traverser` to its `Traverser.sack()` value.
      Specified by:
        `sack` in interface `GraphTraversal<S,E>`
      Parameters:
        `sackOperator` - the operator to apply to the sack value
      Returns:
        the traversal with an appended `SackStep`.
      See Also:
        Reference Documentation - Sack Step

    - #### store

          default CredentialTraversal<S,E> store(String sideEffectKey)

      Description copied from interface: `GraphTraversal`
      Lazily aggregates objects in the stream into a side-effect collection.
      Specified by:
        `store` in interface `GraphTraversal<S,E>`
      Parameters:
        `sideEffectKey` - the name of the side-effect key that will hold the aggregate
      Returns:
        the traversal with an appended `AggregateLocalStep`
      See Also:
        Reference Documentation - Store Step

    - #### profile

          default CredentialTraversal<S,E> profile(String sideEffectKey)

      Description copied from interface: `GraphTraversal`
      Allows developers to examine statistical information about a traversal providing data like execution times, counts, etc.
      Specified by:
        `profile` in interface `GraphTraversal<S,E>`
      Parameters:
        `sideEffectKey` - the name of the side-effect key within which to hold the profile object
      Returns:
        the traversal with an appended `ProfileSideEffectStep`
      See Also:
        Reference Documentation - Profile Step

    - #### profile

          default CredentialTraversal<S,TraversalMetrics> profile()

      Description copied from interface: `Traversal`
      Profile the traversal.
      Specified by:
        `profile` in interface `GraphTraversal<S,E>`
      Specified by:
        `profile` in interface `Traversal<S,E>`
      Returns:
        the updated traversal with respective `ProfileSideEffectStep`.
      See Also:
        Reference Documentation - Profile Step

    - #### none

          default CredentialTraversal<S,E> none()

      Description copied from interface: `Traversal`
      Filter all traversers in the traversal. This step has narrow use cases and is primarily intended for use as a signal to remote servers that `Traversal.iterate()` was called. While it may be directly used, it is often a sign that a traversal should be re-written in another form.
      Specified by:
        `none` in interface `GraphTraversal<S,E>`
      Specified by:
        `none` in interface `Traversal<S,E>`
      Returns:
        the updated traversal with respective `NoneStep`.

    - #### property

          default CredentialTraversal<S,E> property(VertexProperty.Cardinality cardinality,
                                                    Object key,
                                                    Object value,
                                                    Object... keyValues)

      Description copied from interface: `GraphTraversal`
      Sets a `Property` value and related meta properties if supplied, if supported by the `Graph` and if the `Element` is a `VertexProperty`. This method is the long-hand version of `GraphTraversal.property(Object, Object, Object...)` with the difference that the `VertexProperty.Cardinality` can be supplied.

      Generally speaking, this method will append an `AddPropertyStep` to the `Traversal` but when possible, this method will attempt to fold key/value pairs into an `AddVertexStep`, `AddEdgeStep` or `AddVertexStartStep`. This potential optimization can only happen if cardinality is not supplied and when meta-properties are not included.
      Specified by:
        `property` in interface `GraphTraversal<S,E>`
      Parameters:
        `cardinality` - the specified cardinality of the property where `null` will allow the `Graph` to use its default settings
        `key` - the key for the property
        `value` - the value for the property
        `keyValues` - any meta properties to be assigned to this property
      Returns:
        the traversal with the last step modified to add a property
      See Also:
        AddProperty Step

    - #### property

          default CredentialTraversal<S,E> property(Object key,
                                                    Object value,
                                                    Object... keyValues)

      Description copied from interface: `GraphTraversal`
      Sets the key and value of a `Property`. If the `Element` is a `VertexProperty` and the `Graph` supports it, meta properties can be set. Use of this method assumes that the `VertexProperty.Cardinality` is defaulted to `null` which means that the default cardinality for the `Graph` will be used.

      This method is effectively calls `GraphTraversal.property(VertexProperty.Cardinality, Object, Object, Object...)` as `property(null, key, value, keyValues`.
      Specified by:
        `property` in interface `GraphTraversal<S,E>`
      Parameters:
        `key` - the key for the property
        `value` - the value for the property
        `keyValues` - any meta properties to be assigned to this property
      Returns:
        the traversal with the last step modified to add a property
      See Also:
        AddProperty Step

    - #### branch

          default <M,E2> CredentialTraversal<S,E2> branch(Traversal<?,M> branchTraversal)

      Description copied from interface: `GraphTraversal`
      Split the `Traverser` to all the specified traversals.
      Specified by:
        `branch` in interface `GraphTraversal<S,E>`
      Parameters:
        `branchTraversal` - the traversal to branch the `Traverser` to
      Returns:
        the `Traversal` with the `BranchStep` added
      See Also:
        Reference Documentation - General Steps

    - #### branch

          default <M,E2> CredentialTraversal<S,E2> branch(Function<Traverser<E>,M> function)

      Description copied from interface: `GraphTraversal`
      Split the `Traverser` to all the specified functions.
      Specified by:
        `branch` in interface `GraphTraversal<S,E>`
      Parameters:
        `function` - the traversal to branch the `Traverser` to
      Returns:
        the `Traversal` with the `BranchStep` added
      See Also:
        Reference Documentation - General Steps

    - #### choose

          default <M,E2> CredentialTraversal<S,E2> choose(Traversal<?,M> choiceTraversal)

      Description copied from interface: `GraphTraversal`
      Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal. A `choose` is modified by `GraphTraversal.option(M, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?, E2>)` which provides the various branch choices.
      Specified by:
        `choose` in interface `GraphTraversal<S,E>`
      Parameters:
        `choiceTraversal` - the traversal used to determine the value for the branch
      Returns:
        the traversal with the appended `ChooseStep`
      See Also:
        Reference Documentation - Choose Step

    - #### choose

          default <E2> CredentialTraversal<S,E2> choose(Traversal<?,?> traversalPredicate,
                                                        Traversal<?,E2> trueChoice,
                                                        Traversal<?,E2> falseChoice)

      Description copied from interface: `GraphTraversal`
      Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
      Specified by:
        `choose` in interface `GraphTraversal<S,E>`
      Parameters:
        `traversalPredicate` - the traversal used to determine the "if" portion of the if-then-else
        `trueChoice` - the traversal to execute in the event the `traversalPredicate` returns true
        `falseChoice` - the traversal to execute in the event the `traversalPredicate` returns false
      Returns:
        the traversal with the appended `ChooseStep`
      See Also:
        Reference Documentation - Choose Step

    - #### choose

          default <E2> CredentialTraversal<S,E2> choose(Traversal<?,?> traversalPredicate,
                                                        Traversal<?,E2> trueChoice)

      Description copied from interface: `GraphTraversal`
      Routes the current traverser to a particular traversal branch option which allows the creation of if-then like semantics within a traversal.
      Specified by:
        `choose` in interface `GraphTraversal<S,E>`
      Parameters:
        `traversalPredicate` - the traversal used to determine the "if" portion of the if-then-else
        `trueChoice` - the traversal to execute in the event the `traversalPredicate` returns true
      Returns:
        the traversal with the appended `ChooseStep`
      See Also:
        Reference Documentation - Choose Step

    - #### choose

          default <M,E2> CredentialTraversal<S,E2> choose(Function<E,M> choiceFunction)

      Description copied from interface: `GraphTraversal`
      Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal. A `choose` is modified by `GraphTraversal.option(M, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?, E2>)` which provides the various branch choices.
      Specified by:
        `choose` in interface `GraphTraversal<S,E>`
      Parameters:
        `choiceFunction` - the function used to determine the value for the branch
      Returns:
        the traversal with the appended `ChooseStep`
      See Also:
        Reference Documentation - Choose Step

    - #### choose

          default <E2> CredentialTraversal<S,E2> choose(Predicate<E> choosePredicate,
                                                        Traversal<?,E2> trueChoice,
                                                        Traversal<?,E2> falseChoice)

      Description copied from interface: `GraphTraversal`
      Routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.
      Specified by:
        `choose` in interface `GraphTraversal<S,E>`
      Parameters:
        `choosePredicate` - the function used to determine the "if" portion of the if-then-else
        `trueChoice` - the traversal to execute in the event the `traversalPredicate` returns true
        `falseChoice` - the traversal to execute in the event the `traversalPredicate` returns false
      Returns:
        the traversal with the appended `ChooseStep`
      See Also:
        Reference Documentation - Choose Step

    - #### choose

          default <E2> CredentialTraversal<S,E2> choose(Predicate<E> choosePredicate,
                                                        Traversal<?,E2> trueChoice)

      Description copied from interface: `GraphTraversal`
      Routes the current traverser to a particular traversal branch option which allows the creation of if-then like semantics within a traversal.
      Specified by:
        `choose` in interface `GraphTraversal<S,E>`
      Parameters:
        `choosePredicate` - the function used to determine the "if" portion of the if-then-else
        `trueChoice` - the traversal to execute in the event the `traversalPredicate` returns true
      Returns:
        the traversal with the appended `ChooseStep`
      See Also:
        Reference Documentation - Choose Step

    - #### optional

          default <E2> CredentialTraversal<S,E2> optional(Traversal<?,E2> optionalTraversal)

      Description copied from interface: `GraphTraversal`
      Returns the result of the specified traversal if it yields a result, otherwise it returns the calling element.
      Specified by:
        `optional` in interface `GraphTraversal<S,E>`
      Parameters:
        `optionalTraversal` - the traversal to execute for a potential result
      Returns:
        the traversal with the appended `ChooseStep`
      See Also:
        Reference Documentation - Optional Step

    - #### union

          default <E2> CredentialTraversal<S,E2> union(Traversal<?,E2>... unionTraversals)

      Description copied from interface: `GraphTraversal`
      Merges the results of an arbitrary number of traversals.
      Specified by:
        `union` in interface `GraphTraversal<S,E>`
      Parameters:
        `unionTraversals` - the traversals to merge
      Returns:
        the traversal with the appended `UnionStep`
      See Also:
        Reference Documentation - Union Step

    - #### coalesce

          default <E2> CredentialTraversal<S,E2> coalesce(Traversal<?,E2>... coalesceTraversals)

      Description copied from interface: `GraphTraversal`
      Evaluates the provided traversals and returns the result of the first traversal to emit at least one object.
      Specified by:
        `coalesce` in interface `GraphTraversal<S,E>`
      Parameters:
        `coalesceTraversals` - the traversals to coalesce
      Returns:
        the traversal with the appended `CoalesceStep`
      See Also:
        Reference Documentation - Coalesce Step

    - #### repeat

          default CredentialTraversal<S,E> repeat(Traversal<?,E> repeatTraversal)

      Description copied from interface: `GraphTraversal`
      This step is used for looping over a traversal given some break predicate.
      Specified by:
        `repeat` in interface `GraphTraversal<S,E>`
      Parameters:
        `repeatTraversal` - the traversal to repeat over
      Returns:
        the traversal with the appended `RepeatStep`
      See Also:
        Reference Documentation - Repeat Step

    - #### repeat

          default CredentialTraversal<S,E> repeat(String loopName,
                                                  Traversal<?,E> repeatTraversal)

      Description copied from interface: `GraphTraversal`
      This step is used for looping over a traversal given some break predicate and with a specified loop name.
      Specified by:
        `repeat` in interface `GraphTraversal<S,E>`
      Parameters:
        `loopName` - The name given to the loop
        `repeatTraversal` - the traversal to repeat over
      Returns:
        the traversal with the appended `RepeatStep`
      See Also:
        Reference Documentation - Repeat Step

    - #### emit

          default CredentialTraversal<S,E> emit(Traversal<?,?> emitTraversal)

      Description copied from interface: `GraphTraversal`
      Emit is used in conjunction with `GraphTraversal.repeat(Traversal)` to determine what objects get emit from the loop.
      Specified by:
        `emit` in interface `GraphTraversal<S,E>`
      Parameters:
        `emitTraversal` - the emit predicate defined as a traversal
      Returns:
        the traversal with the appended `RepeatStep`
      See Also:
        Reference Documentation - Repeat Step

    - #### emit

          default CredentialTraversal<S,E> emit(Predicate<Traverser<E>> emitPredicate)

      Description copied from interface: `GraphTraversal`
      Emit is used in conjunction with `GraphTraversal.repeat(Traversal)` to determine what objects get emit from the loop.
      Specified by:
        `emit` in interface `GraphTraversal<S,E>`
      Parameters:
        `emitPredicate` - the emit predicate
      Returns:
        the traversal with the appended `RepeatStep`
      See Also:
        Reference Documentation - Repeat Step

    - #### emit

          default CredentialTraversal<S,E> emit()

      Description copied from interface: `GraphTraversal`
      Emit is used in conjunction with `GraphTraversal.repeat(Traversal)` to emit all objects from the loop.
      Specified by:
        `emit` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the appended `RepeatStep`
      See Also:
        Reference Documentation - Repeat Step

    - #### until

          default CredentialTraversal<S,E> until(Traversal<?,?> untilTraversal)

      Description copied from interface: `GraphTraversal`
      Modifies a `GraphTraversal.repeat(Traversal)` to determine when the loop should exit.
      Specified by:
        `until` in interface `GraphTraversal<S,E>`
      Parameters:
        `untilTraversal` - the traversal that determines when the loop exits
      Returns:
        the traversal with the appended `RepeatStep`
      See Also:
        Reference Documentation - Repeat Step

    - #### until

          default CredentialTraversal<S,E> until(Predicate<Traverser<E>> untilPredicate)

      Description copied from interface: `GraphTraversal`
      Modifies a `GraphTraversal.repeat(Traversal)` to determine when the loop should exit.
      Specified by:
        `until` in interface `GraphTraversal<S,E>`
      Parameters:
        `untilPredicate` - the predicate that determines when the loop exits
      Returns:
        the traversal with the appended `RepeatStep`
      See Also:
        Reference Documentation - Repeat Step

    - #### times

          default CredentialTraversal<S,E> times(int maxLoops)

      Description copied from interface: `GraphTraversal`
      Modifies a `GraphTraversal.repeat(Traversal)` to specify how many loops should occur before exiting.
      Specified by:
        `times` in interface `GraphTraversal<S,E>`
      Parameters:
        `maxLoops` - the number of loops to execute prior to exiting
      Returns:
        the traversal with the appended `RepeatStep`
      See Also:
        Reference Documentation - Repeat Step

    - #### local

          default <E2> CredentialTraversal<S,E2> local(Traversal<?,E2> localTraversal)

      Description copied from interface: `GraphTraversal`
      Provides a execute a specified traversal on a single element within a stream.
      Specified by:
        `local` in interface `GraphTraversal<S,E>`
      Parameters:
        `localTraversal` - the traversal to execute locally
      Returns:
        the traversal with the appended `LocalStep`
      See Also:
        Reference Documentation - Local Step

    - #### pageRank

          default CredentialTraversal<S,E> pageRank()

      Description copied from interface: `GraphTraversal`
      Calculates a PageRank over the graph using a 0.85 for the `alpha` value.
      Specified by:
        `pageRank` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the appended `PageRankVertexProgramStep`
      See Also:
        Reference Documentation - PageRank Step

    - #### pageRank

          default CredentialTraversal<S,E> pageRank(double alpha)

      Description copied from interface: `GraphTraversal`
      Calculates a PageRank over the graph.
      Specified by:
        `pageRank` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the appended `PageRankVertexProgramStep`
      See Also:
        Reference Documentation - PageRank Step

    - #### peerPressure

          default CredentialTraversal<S,E> peerPressure()

      Description copied from interface: `GraphTraversal`
      Executes a Peer Pressure community detection algorithm over the graph.
      Specified by:
        `peerPressure` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the appended `PeerPressureVertexProgramStep`
      See Also:
        Reference Documentation - PeerPressure Step

    - #### connectedComponent

          default CredentialTraversal<S,E> connectedComponent()

      Description copied from interface: `GraphTraversal`
      Executes a Connected Component algorithm over the graph.
      Specified by:
        `connectedComponent` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the appended `ConnectedComponentVertexProgram`
      See Also:
        Reference Documentation - ConnectedComponent Step

    - #### shortestPath

          default CredentialTraversal<S,Path> shortestPath()

      Description copied from interface: `GraphTraversal`
      Executes a Shortest Path algorithm over the graph.
      Specified by:
        `shortestPath` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the appended `ShortestPathVertexProgramStep`
      See Also:
        Reference Documentation - ShortestPath Step

    - #### program

          default CredentialTraversal<S,E> program(VertexProgram<?> vertexProgram)

      Description copied from interface: `GraphTraversal`
      Executes an arbitrary `VertexProgram` over the graph.
      Specified by:
        `program` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the appended `ProgramVertexProgramStep`
      See Also:
        Reference Documentation - Program Step

    - #### as

          default CredentialTraversal<S,E> as(String stepLabel,
                                              String... stepLabels)

      Description copied from interface: `GraphTraversal`
      A step modulator that provides a label to the step that can be accessed later in the traversal by other steps.
      Specified by:
        `as` in interface `GraphTraversal<S,E>`
      Parameters:
        `stepLabel` - the name of the step
        `stepLabels` - additional names for the label
      Returns:
        the traversal with the modified end step
      See Also:
        Reference Documentation - As Step

    - #### barrier

          default CredentialTraversal<S,E> barrier()

      Description copied from interface: `GraphTraversal`
      Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier. In this case, it iterates the entire thing as the default barrier size is set to `Integer.MAX_VALUE`.
      Specified by:
        `barrier` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `NoOpBarrierStep`
      See Also:
        Reference Documentation - Barrier Step

    - #### barrier

          default CredentialTraversal<S,E> barrier(int maxBarrierSize)

      Description copied from interface: `GraphTraversal`
      Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier.
      Specified by:
        `barrier` in interface `GraphTraversal<S,E>`
      Parameters:
        `maxBarrierSize` - the size of the barrier
      Returns:
        the traversal with an appended `NoOpBarrierStep`
      See Also:
        Reference Documentation - Barrier Step

    - #### index

          default <E2> CredentialTraversal<S,E2> index()

      Description copied from interface: `GraphTraversal`
      Indexes all items of the current collection. The indexing format can be configured using the `GraphTraversal.with(String, Object)` and `WithOptions.indexer`. Indexed as list: ["a","b","c"] => [["a",0],["b",1],["c",2]] Indexed as map: ["a","b","c"] => {0:"a",1:"b",2:"c"} If the current object is not a collection, this step will map the object to a single item collection/map: Indexed as list: "a" => ["a",0] Indexed as map: "a" => {0:"a"}
      Specified by:
        `index` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with an appended `IndexStep`
      See Also:
        Reference Documentation - Index Step

    - #### barrier

          default CredentialTraversal<S,E> barrier(Consumer<TraverserSet<Object>> barrierConsumer)

      Description copied from interface: `GraphTraversal`
      Turns the lazy traversal pipeline into a bulk-synchronous pipeline which basically iterates that traversal to the size of the barrier. In this case, it iterates the entire thing as the default barrier size is set to `Integer.MAX_VALUE`.
      Specified by:
        `barrier` in interface `GraphTraversal<S,E>`
      Parameters:
        `barrierConsumer` - a consumer function that is applied to the objects aggregated to the barrier
      Returns:
        the traversal with an appended `NoOpBarrierStep`
      See Also:
        Reference Documentation - Barrier Step

    - #### with

          default CredentialTraversal<S,E> with(String key)

      Description copied from interface: `GraphTraversal`
      Provides a configuration to a step in the form of a key which is the same as `with(key, true)`. The key of the configuration must be step specific and therefore a configuration could be supplied that is not known to be valid until execution.
      Specified by:
        `with` in interface `GraphTraversal<S,E>`
      Parameters:
        `key` - the key of the configuration to apply to a step
      Returns:
        the traversal with a modulated step
      See Also:
        Reference Documentation - With Step

    - #### with

          default CredentialTraversal<S,E> with(String key,
                                                Object value)

      Description copied from interface: `GraphTraversal`
      Provides a configuration to a step in the form of a key and value pair. The key of the configuration must be step specific and therefore a configuration could be supplied that is not known to be valid until execution.
      Specified by:
        `with` in interface `GraphTraversal<S,E>`
      Parameters:
        `key` - the key of the configuration to apply to a step
        `value` - the value of the configuration to apply to a step
      Returns:
        the traversal with a modulated step
      See Also:
        Reference Documentation - With Step

    - #### by

          default CredentialTraversal<S,E> by()

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. This form is essentially an `GraphTraversal.identity()` modulation.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### by

          default CredentialTraversal<S,E> by(Traversal<?,?> traversal)

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified traversal.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Parameters:
        `traversal` - the traversal to apply
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### by

          default CredentialTraversal<S,E> by(T token)

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified token of `T`.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Parameters:
        `token` - the token to apply
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### by

          default CredentialTraversal<S,E> by(String key)

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified key.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Parameters:
        `key` - the key to apply
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### by

          default <V> CredentialTraversal<S,E> by(Function<V,Object> function)

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Parameters:
        `function` - the function to apply
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### by

          default <V> CredentialTraversal<S,E> by(Traversal<?,?> traversal,
                                                  Comparator<V> comparator)

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Parameters:
        `traversal` - the traversal to apply
        `comparator` - the comparator to apply typically for some `GraphTraversal.order()`
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### by

          default CredentialTraversal<S,E> by(Comparator<E> comparator)

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Parameters:
        `comparator` - the comparator to apply typically for some `GraphTraversal.order()`
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### by

          default CredentialTraversal<S,E> by(Order order)

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Parameters:
        `order` - the comparator to apply typically for some `GraphTraversal.order()`
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### by

          default <V> CredentialTraversal<S,E> by(String key,
                                                  Comparator<V> comparator)

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Parameters:
        `key` - the key to apply traversal
        `comparator` - the comparator to apply typically for some `GraphTraversal.order()`
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### by

          default <U> CredentialTraversal<S,E> by(Function<U,Object> function,
                                                  Comparator comparator)

      Description copied from interface: `GraphTraversal`
      The `by()` can be applied to a number of different step to alter their behaviors. Modifies the previous step with the specified function.
      Specified by:
        `by` in interface `GraphTraversal<S,E>`
      Parameters:
        `function` - the function to apply
        `comparator` - the comparator to apply typically for some `GraphTraversal.order()`
      Returns:
        the traversal with a modulated step.
      See Also:
        Reference Documentation - By Step

    - #### option

          default <M,E2> CredentialTraversal<S,E> option(M pick,
                                                         Traversal<?,E2> traversalOption)

      Description copied from interface: `GraphTraversal`
      This step modifies `GraphTraversal.choose(Function)` to specifies the available choices that might be executed.
      Specified by:
        `option` in interface `GraphTraversal<S,E>`
      Parameters:
        `pick` - the token that would trigger this option which may be a `TraversalOptionParent.Pick`, a `Traversal`, `Predicate`, or object depending on the step being modulated.
        `traversalOption` - the option as a traversal
      Returns:
        the traversal with the modulated step
      See Also:
        Reference Documentation - Choose Step

    - #### option

          default <E2> CredentialTraversal<S,E> option(Traversal<?,E2> traversalOption)

      Description copied from interface: `GraphTraversal`
      This step modifies `GraphTraversal.choose(Function)` to specifies the available choices that might be executed.
      Specified by:
        `option` in interface `GraphTraversal<S,E>`
      Parameters:
        `traversalOption` - the option as a traversal
      Returns:
        the traversal with the modulated step
      See Also:
        Reference Documentation - Choose Step

    - #### read

          default CredentialTraversal<S,E> read()

      Description copied from interface: `GraphTraversal`
      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.
      Specified by:
        `read` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the `IoStep` modulated to read
      See Also:
        Reference Documentation - IO Step, Reference Documentation - Read Step

    - #### write

          default CredentialTraversal<S,E> write()

      Description copied from interface: `GraphTraversal`
      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.
      Specified by:
        `write` in interface `GraphTraversal<S,E>`
      Returns:
        the traversal with the `IoStep` modulated to write
      See Also:
        Reference Documentation - IO Step, Reference Documentation - Write Step

    - #### iterate

          default CredentialTraversal<S,E> iterate()

      Description copied from interface: `Traversal`
      Iterate all the `Traverser` instances in the traversal. What is returned is the empty traversal. It is assumed that what is desired from the computation is are the sideEffects yielded by the traversal.
      Specified by:
        `iterate` in interface `GraphTraversal<S,E>`
      Specified by:
        `iterate` in interface `GraphTraversal.Admin<S,E>`
      Specified by:
        `iterate` in interface `Traversal<S,E>`
      Returns:
        the fully drained traversal

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