gremlin 3.8.1 → 4.0.0-beta.2

package/build/esm/process/graph-traversal.js

@@ -0,0 +1,1693 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * @author Jorge Bay Gondra
+ */
+import { Traversal, cardinality } from './traversal.js';
+import { Transaction } from './transaction.js';
+import { TraversalStrategies, VertexProgramStrategy, OptionsStrategy } from './traversal-strategy.js';
+import { Vertex } from '../structure/graph.js';
+import GremlinLang from './gremlin-lang.js';
+/**
+ * Represents the primary DSL of the Gremlin traversal machine.
+ */
+export class GraphTraversalSource {
+    graph;
+    traversalStrategies;
+    gremlinLang;
+    graphTraversalSourceClass;
+    graphTraversalClass;
+    remoteConnection;
+    /**
+     * Creates a new instance of {@link GraphTraversalSource}.
+     * @param {Graph} graph
+     * @param {TraversalStrategies} traversalStrategies
+     * @param {GremlinLang} [gremlinLang] Optional GremlinLang instance.
+     * @param {Function} [graphTraversalSourceClass] Optional {@link GraphTraversalSource} constructor.
+     * @param {Function} [graphTraversalClass] Optional {@link GraphTraversal} constructor.
+     */
+    constructor(graph, traversalStrategies, gremlinLang = new GremlinLang(), graphTraversalSourceClass = GraphTraversalSource, graphTraversalClass = GraphTraversal) {
+        this.graph = graph;
+        this.traversalStrategies = traversalStrategies;
+        this.gremlinLang = gremlinLang;
+        this.graphTraversalSourceClass = graphTraversalSourceClass;
+        this.graphTraversalClass = graphTraversalClass;
+        const strat = traversalStrategies.strategies.find((ts) => ts.strategyName === 'RemoteStrategy');
+        this.remoteConnection = strat !== undefined ? strat.connection : undefined;
+    }
+    /**
+     * Spawn a new <code>Transaction</code> object that can then start and stop a transaction.
+     * @returns {Transaction}
+     */
+    tx() {
+        // you can't do g.tx().begin().tx() - no child transactions
+        if (this.remoteConnection) {
+            throw new Error('This TraversalSource is already bound to a transaction - child transactions are not supported');
+        }
+        return new Transaction(this);
+    }
+    /**
+     * @param graphComputer
+     * @param workers
+     * @param result
+     * @param persist
+     * @param vertices
+     * @param edges
+     * @param configuration
+     * @returns {GraphTraversalSource}
+     */
+    withComputer(graphComputer, workers, result, persist, vertices, edges, configuration) {
+        const m = {};
+        if (graphComputer !== undefined) {
+            m.graphComputer = graphComputer;
+        }
+        if (workers !== undefined) {
+            m.workers = workers;
+        }
+        if (result !== undefined) {
+            m.result = result;
+        }
+        if (persist !== undefined) {
+            m.graphComputer = persist;
+        }
+        if (vertices !== undefined) {
+            m.vertices = vertices;
+        }
+        if (edges !== undefined) {
+            m.edges = edges;
+        }
+        if (configuration !== undefined) {
+            m.configuration = configuration;
+        }
+        return this.withStrategies(new VertexProgramStrategy(m));
+    }
+    /**
+     * Graph Traversal Source with method.
+     * @param {String} key
+     * @param {Object} value if not specified, the value with default to `true`
+     * @returns {GraphTraversalSource}
+     */
+    with_(key, value = undefined) {
+        const val = value === undefined ? true : value;
+        const glStrategies = this.gremlinLang.getOptionsStrategies();
+        if (glStrategies.length === 0) {
+            return this.withStrategies(new OptionsStrategy({ [key]: val }));
+        }
+        glStrategies[glStrategies.length - 1].configuration[key] = val;
+        const gl = new GremlinLang(this.gremlinLang);
+        return new this.graphTraversalSourceClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl, this.graphTraversalSourceClass, this.graphTraversalClass);
+    }
+    /**
+     * Returns the string representation of the GraphTraversalSource.
+     * @returns {string}
+     */
+    toString() {
+        return 'graphtraversalsource[' + this.graph.toString() + ']';
+    }
+    /**
+     * Graph Traversal Source withBulk method.
+     * @param {...Object} args
+     * @returns {GraphTraversalSource}
+     */
+    withBulk(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addSource('withBulk', args);
+        return new this.graphTraversalSourceClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl, this.graphTraversalSourceClass, this.graphTraversalClass);
+    }
+    /**
+     * Graph Traversal Source withPath method.
+     * @param {...Object} args
+     * @returns {GraphTraversalSource}
+     */
+    withPath(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addSource('withPath', args);
+        return new this.graphTraversalSourceClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl, this.graphTraversalSourceClass, this.graphTraversalClass);
+    }
+    /**
+     * Graph Traversal Source withSack method.
+     * @param {...Object} args
+     * @returns {GraphTraversalSource}
+     */
+    withSack(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addSource('withSack', args);
+        return new this.graphTraversalSourceClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl, this.graphTraversalSourceClass, this.graphTraversalClass);
+    }
+    /**
+     * Graph Traversal Source withSideEffect method.
+     * @param {...Object} args
+     * @returns {GraphTraversalSource}
+     */
+    withSideEffect(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addSource('withSideEffect', args);
+        return new this.graphTraversalSourceClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl, this.graphTraversalSourceClass, this.graphTraversalClass);
+    }
+    /**
+     * Graph Traversal Source withStrategies method.
+     * @param {...Object} args
+     * @returns {GraphTraversalSource}
+     */
+    withStrategies(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addSource('withStrategies', args);
+        return new this.graphTraversalSourceClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl, this.graphTraversalSourceClass, this.graphTraversalClass);
+    }
+    /**
+     * Graph Traversal Source withoutStrategies method.
+     * @param {...Object} args
+     * @returns {GraphTraversalSource}
+     */
+    withoutStrategies(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addSource('withoutStrategies', args);
+        return new this.graphTraversalSourceClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl, this.graphTraversalSourceClass, this.graphTraversalClass);
+    }
+    /**
+     * E GraphTraversalSource step method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    E(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addStep('E', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+    /**
+     * V GraphTraversalSource step method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    V(...args) {
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] instanceof Vertex) {
+                args[i] = args[i].id;
+            }
+        }
+        const gl = new GremlinLang(this.gremlinLang).addStep('V', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+    /**
+     * addE GraphTraversalSource step method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    addE(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addStep('addE', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+    /**
+     * mergeV GraphTraversalSource step method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    mergeE(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addStep('mergeE', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+    /**
+     * addV GraphTraversalSource step method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    addV(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addStep('addV', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+    /**
+     * mergeV GraphTraversalSource step method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    mergeV(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addStep('mergeV', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+    /**
+     * inject GraphTraversalSource step method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    inject(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addStep('inject', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+    /**
+     * io GraphTraversalSource step method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    io(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addStep('io', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+    /**
+     * call GraphTraversalSource step method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    call(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addStep('call', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+    /**
+     * union GraphTraversalSource method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    union(...args) {
+        const gl = new GremlinLang(this.gremlinLang).addStep('union', args);
+        return new this.graphTraversalClass(this.graph, new TraversalStrategies(this.traversalStrategies), gl);
+    }
+}
+/**
+ * Represents a graph traversal.
+ */
+export class GraphTraversal extends Traversal {
+    constructor(graph, traversalStrategies, gremlinLang) {
+        super(graph, traversalStrategies, gremlinLang);
+    }
+    /**
+     * Copy a traversal so as to reset and re-use it.
+     */
+    clone() {
+        return new GraphTraversal(this.graph, this.traversalStrategies, new GremlinLang(this.gremlinLang));
+    }
+    /**
+     * Graph traversal V method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    V(...args) {
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] instanceof Vertex) {
+                args[i] = args[i].id;
+            }
+        }
+        this.gremlinLang.addStep('V', args);
+        return this;
+    }
+    /**
+     * Graph traversal E method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    E(...args) {
+        this.gremlinLang.addStep('E', args);
+        return this;
+    }
+    /**
+     * Graph traversal addE method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    addE(...args) {
+        this.gremlinLang.addStep('addE', args);
+        return this;
+    }
+    /**
+     * Graph traversal addV method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    addV(...args) {
+        this.gremlinLang.addStep('addV', args);
+        return this;
+    }
+    /**
+     * Graph traversal aggregate method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    aggregate(...args) {
+        this.gremlinLang.addStep('aggregate', args);
+        return this;
+    }
+    /**
+     * Graph traversal all method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    all(...args) {
+        this.gremlinLang.addStep('all', args);
+        return this;
+    }
+    /**
+     * Graph traversal and method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    and(...args) {
+        this.gremlinLang.addStep('and', args);
+        return this;
+    }
+    /**
+     * Graph traversal any method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    any(...args) {
+        this.gremlinLang.addStep('any', args);
+        return this;
+    }
+    /**
+     * Graph traversal as method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    as(...args) {
+        this.gremlinLang.addStep('as', args);
+        return this;
+    }
+    /**
+     * Graph traversal asBool method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    asBool(...args) {
+        this.gremlinLang.addStep('asBool', args);
+        return this;
+    }
+    /**
+     * Graph traversal asDate method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    asDate(...args) {
+        this.gremlinLang.addStep('asDate', args);
+        return this;
+    }
+    /**
+     * Graph traversal asNumber method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    asNumber(...args) {
+        this.gremlinLang.addStep('asNumber', args);
+        return this;
+    }
+    /**
+     * Graph traversal asString method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    asString(...args) {
+        this.gremlinLang.addStep('asString', args);
+        return this;
+    }
+    /**
+     * Graph traversal barrier method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    barrier(...args) {
+        this.gremlinLang.addStep('barrier', args);
+        return this;
+    }
+    /**
+     * Graph traversal both method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    both(...args) {
+        this.gremlinLang.addStep('both', args);
+        return this;
+    }
+    /**
+     * Graph traversal bothE method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    bothE(...args) {
+        this.gremlinLang.addStep('bothE', args);
+        return this;
+    }
+    /**
+     * Graph traversal bothV method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    bothV(...args) {
+        this.gremlinLang.addStep('bothV', args);
+        return this;
+    }
+    /**
+     * Graph traversal branch method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    branch(...args) {
+        this.gremlinLang.addStep('branch', args);
+        return this;
+    }
+    /**
+     * Graph traversal by method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    by(...args) {
+        this.gremlinLang.addStep('by', args);
+        return this;
+    }
+    /**
+     * Graph traversal call method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    call(...args) {
+        this.gremlinLang.addStep('call', args);
+        return this;
+    }
+    /**
+     * Graph traversal cap method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    cap(...args) {
+        this.gremlinLang.addStep('cap', args);
+        return this;
+    }
+    /**
+     * Graph traversal choose method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    choose(...args) {
+        this.gremlinLang.addStep('choose', args);
+        return this;
+    }
+    /**
+     * Graph traversal coalesce method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    coalesce(...args) {
+        this.gremlinLang.addStep('coalesce', args);
+        return this;
+    }
+    /**
+     * Graph traversal coin method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    coin(...args) {
+        this.gremlinLang.addStep('coin', args);
+        return this;
+    }
+    /**
+     * Graph traversal combine method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    combine(...args) {
+        this.gremlinLang.addStep('combine', args);
+        return this;
+    }
+    /**
+     * Graph traversal concat method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    concat(...args) {
+        this.gremlinLang.addStep('concat', args);
+        return this;
+    }
+    /**
+     * Graph traversal conjoin method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    conjoin(...args) {
+        this.gremlinLang.addStep('conjoin', args);
+        return this;
+    }
+    /**
+     * Graph traversal connectedComponent method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    connectedComponent(...args) {
+        this.gremlinLang.addStep('connectedComponent', args);
+        return this;
+    }
+    /**
+     * Graph traversal constant method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    constant(...args) {
+        this.gremlinLang.addStep('constant', args);
+        return this;
+    }
+    /**
+     * Graph traversal count method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    count(...args) {
+        this.gremlinLang.addStep('count', args);
+        return this;
+    }
+    /**
+     * Graph traversal cyclicPath method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    cyclicPath(...args) {
+        this.gremlinLang.addStep('cyclicPath', args);
+        return this;
+    }
+    /**
+     * Graph traversal dateAdd method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    dateAdd(...args) {
+        this.gremlinLang.addStep('dateAdd', args);
+        return this;
+    }
+    /**
+     * Graph traversal dateDiff method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    dateDiff(...args) {
+        this.gremlinLang.addStep('dateDiff', args);
+        return this;
+    }
+    /**
+     * Graph traversal dedup method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    dedup(...args) {
+        this.gremlinLang.addStep('dedup', args);
+        return this;
+    }
+    /**
+     * Graph traversal difference method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    difference(...args) {
+        this.gremlinLang.addStep('difference', args);
+        return this;
+    }
+    /**
+     * Graph traversal discard method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    discard(...args) {
+        this.gremlinLang.addStep('discard', args);
+        return this;
+    }
+    /**
+     * Graph traversal disjunct method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    disjunct(...args) {
+        this.gremlinLang.addStep('disjunct', args);
+        return this;
+    }
+    /**
+     * Graph traversal drop method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    drop(...args) {
+        this.gremlinLang.addStep('drop', args);
+        return this;
+    }
+    /**
+     * Graph traversal element method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    element(...args) {
+        this.gremlinLang.addStep('element', args);
+        return this;
+    }
+    /**
+     * Graph traversal elementMap method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    elementMap(...args) {
+        this.gremlinLang.addStep('elementMap', args);
+        return this;
+    }
+    /**
+     * Graph traversal emit method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    emit(...args) {
+        this.gremlinLang.addStep('emit', args);
+        return this;
+    }
+    /**
+     * Graph traversal fa method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    fail(...args) {
+        this.gremlinLang.addStep('fail', args);
+        return this;
+    }
+    /**
+     * Graph traversal filter method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    filter(...args) {
+        this.gremlinLang.addStep('filter', args);
+        return this;
+    }
+    /**
+     * Graph traversal flatMap method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    flatMap(...args) {
+        this.gremlinLang.addStep('flatMap', args);
+        return this;
+    }
+    /**
+     * Graph traversal fold method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    fold(...args) {
+        this.gremlinLang.addStep('fold', args);
+        return this;
+    }
+    /**
+     * Graph traversal format method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    format(...args) {
+        this.gremlinLang.addStep('format', args);
+        return this;
+    }
+    /**
+     * Graph traversal from method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    from_(...args) {
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] instanceof Vertex) {
+                args[i] = args[i].id;
+            }
+        }
+        this.gremlinLang.addStep('from', args);
+        return this;
+    }
+    /**
+     * Graph traversal group method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    group(...args) {
+        this.gremlinLang.addStep('group', args);
+        return this;
+    }
+    /**
+     * Graph traversal groupCount method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    groupCount(...args) {
+        this.gremlinLang.addStep('groupCount', args);
+        return this;
+    }
+    /**
+     * Graph traversal has method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    has(...args) {
+        this.gremlinLang.addStep('has', args);
+        return this;
+    }
+    /**
+     * Graph traversal hasId method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    hasId(...args) {
+        this.gremlinLang.addStep('hasId', args);
+        return this;
+    }
+    /**
+     * Graph traversal hasKey method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    hasKey(...args) {
+        this.gremlinLang.addStep('hasKey', args);
+        return this;
+    }
+    /**
+     * Graph traversal hasLabel method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    hasLabel(...args) {
+        this.gremlinLang.addStep('hasLabel', args);
+        return this;
+    }
+    /**
+     * Graph traversal hasNot method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    hasNot(...args) {
+        this.gremlinLang.addStep('hasNot', args);
+        return this;
+    }
+    /**
+     * Graph traversal hasValue method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    hasValue(...args) {
+        this.gremlinLang.addStep('hasValue', args);
+        return this;
+    }
+    /**
+     * Graph traversal id method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    id(...args) {
+        this.gremlinLang.addStep('id', args);
+        return this;
+    }
+    /**
+     * Graph traversal identity method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    identity(...args) {
+        this.gremlinLang.addStep('identity', args);
+        return this;
+    }
+    /**
+     * Graph traversal in method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    in_(...args) {
+        this.gremlinLang.addStep('in', args);
+        return this;
+    }
+    /**
+     * Graph traversal inE method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    inE(...args) {
+        this.gremlinLang.addStep('inE', args);
+        return this;
+    }
+    /**
+     * Graph traversal inV method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    inV(...args) {
+        this.gremlinLang.addStep('inV', args);
+        return this;
+    }
+    /**
+     * Graph traversal index method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    index(...args) {
+        this.gremlinLang.addStep('index', args);
+        return this;
+    }
+    /**
+     * Graph traversal inject method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    inject(...args) {
+        this.gremlinLang.addStep('inject', args);
+        return this;
+    }
+    /**
+     * Graph traversal intersect method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    intersect(...args) {
+        this.gremlinLang.addStep('intersect', args);
+        return this;
+    }
+    /**
+     * Graph traversal is method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    is(...args) {
+        this.gremlinLang.addStep('is', args);
+        return this;
+    }
+    /**
+     * Graph traversal key method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    key(...args) {
+        this.gremlinLang.addStep('key', args);
+        return this;
+    }
+    /**
+     * Graph traversal label method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    label(...args) {
+        this.gremlinLang.addStep('label', args);
+        return this;
+    }
+    /**
+     * Graph traversal length method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    length(...args) {
+        this.gremlinLang.addStep('length', args);
+        return this;
+    }
+    /**
+     * Graph traversal limit method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    limit(...args) {
+        this.gremlinLang.addStep('limit', args);
+        return this;
+    }
+    /**
+     * Graph traversal local method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    local(...args) {
+        this.gremlinLang.addStep('local', args);
+        return this;
+    }
+    /**
+     * Graph traversal loops method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    loops(...args) {
+        this.gremlinLang.addStep('loops', args);
+        return this;
+    }
+    /**
+     * Graph traversal lTrim method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    lTrim(...args) {
+        this.gremlinLang.addStep('lTrim', args);
+        return this;
+    }
+    /**
+     * Graph traversal map method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    map(...args) {
+        this.gremlinLang.addStep('map', args);
+        return this;
+    }
+    /**
+     * Graph traversal match method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    match(...args) {
+        this.gremlinLang.addStep('match', args);
+        return this;
+    }
+    /**
+     * Graph traversal math method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    math(...args) {
+        this.gremlinLang.addStep('math', args);
+        return this;
+    }
+    /**
+     * Graph traversal max method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    max(...args) {
+        this.gremlinLang.addStep('max', args);
+        return this;
+    }
+    /**
+     * Graph traversal mean method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    mean(...args) {
+        this.gremlinLang.addStep('mean', args);
+        return this;
+    }
+    /**
+     * Graph traversal merge method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    merge(...args) {
+        this.gremlinLang.addStep('merge', args);
+        return this;
+    }
+    /**
+     * Graph traversal mergeE method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    mergeE(...args) {
+        this.gremlinLang.addStep('mergeE', args);
+        return this;
+    }
+    /**
+     * Graph traversal mergeV method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    mergeV(...args) {
+        this.gremlinLang.addStep('mergeV', args);
+        return this;
+    }
+    /**
+     * Graph traversal min method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    min(...args) {
+        this.gremlinLang.addStep('min', args);
+        return this;
+    }
+    /**
+     * Graph traversal none method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    none(...args) {
+        this.gremlinLang.addStep('none', args);
+        return this;
+    }
+    /**
+     * Graph traversal not method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    not(...args) {
+        this.gremlinLang.addStep('not', args);
+        return this;
+    }
+    /**
+     * Graph traversal option method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    option(...args) {
+        this.gremlinLang.addStep('option', args);
+        return this;
+    }
+    /**
+     * Graph traversal optional method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    optional(...args) {
+        this.gremlinLang.addStep('optional', args);
+        return this;
+    }
+    /**
+     * Graph traversal or method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    or(...args) {
+        this.gremlinLang.addStep('or', args);
+        return this;
+    }
+    /**
+     * Graph traversal order method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    order(...args) {
+        this.gremlinLang.addStep('order', args);
+        return this;
+    }
+    /**
+     * Graph traversal otherV method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    otherV(...args) {
+        this.gremlinLang.addStep('otherV', args);
+        return this;
+    }
+    /**
+     * Graph traversal out method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    out(...args) {
+        this.gremlinLang.addStep('out', args);
+        return this;
+    }
+    /**
+     * Graph traversal outE method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    outE(...args) {
+        this.gremlinLang.addStep('outE', args);
+        return this;
+    }
+    /**
+     * Graph traversal outV method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    outV(...args) {
+        this.gremlinLang.addStep('outV', args);
+        return this;
+    }
+    /**
+     * Graph traversal pageRank method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    pageRank(...args) {
+        this.gremlinLang.addStep('pageRank', args);
+        return this;
+    }
+    /**
+     * Graph traversal path method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    path(...args) {
+        this.gremlinLang.addStep('path', args);
+        return this;
+    }
+    /**
+     * Graph traversal peerPressure method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    peerPressure(...args) {
+        this.gremlinLang.addStep('peerPressure', args);
+        return this;
+    }
+    /**
+     * Graph traversal product method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    product(...args) {
+        this.gremlinLang.addStep('product', args);
+        return this;
+    }
+    /**
+     * Graph traversal profile method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    profile(...args) {
+        this.gremlinLang.addStep('profile', args);
+        return this;
+    }
+    /**
+     * Graph traversal program method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    program(...args) {
+        this.gremlinLang.addStep('program', args);
+        return this;
+    }
+    /**
+     * Graph traversal project method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    project(...args) {
+        this.gremlinLang.addStep('project', args);
+        return this;
+    }
+    /**
+     * Graph traversal properties method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    properties(...args) {
+        this.gremlinLang.addStep('properties', args);
+        return this;
+    }
+    /**
+     * Graph traversal property method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    property(...args) {
+        this.gremlinLang.addStep('property', args);
+        return this;
+    }
+    /**
+     * Graph traversal propertyMap method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    propertyMap(...args) {
+        this.gremlinLang.addStep('propertyMap', args);
+        return this;
+    }
+    /**
+     * Graph traversal range method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    range(...args) {
+        this.gremlinLang.addStep('range', args);
+        return this;
+    }
+    /**
+     * Graph traversal read method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    read(...args) {
+        this.gremlinLang.addStep('read', args);
+        return this;
+    }
+    /**
+     * Graph traversal repeat method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    repeat(...args) {
+        this.gremlinLang.addStep('repeat', args);
+        return this;
+    }
+    /**
+     * Graph traversal replace method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    replace(...args) {
+        this.gremlinLang.addStep('replace', args);
+        return this;
+    }
+    /**
+     * Graph traversal reverse method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    reverse(...args) {
+        this.gremlinLang.addStep('reverse', args);
+        return this;
+    }
+    /**
+     * Graph traversal rTrim method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    rTrim(...args) {
+        this.gremlinLang.addStep('rTrim', args);
+        return this;
+    }
+    /**
+     * Graph traversal sack method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    sack(...args) {
+        this.gremlinLang.addStep('sack', args);
+        return this;
+    }
+    /**
+     * Graph traversal sample method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    sample(...args) {
+        this.gremlinLang.addStep('sample', args);
+        return this;
+    }
+    /**
+     * Graph traversal select method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    select(...args) {
+        this.gremlinLang.addStep('select', args);
+        return this;
+    }
+    /**
+     * Graph traversal shortestPath method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    shortestPath(...args) {
+        this.gremlinLang.addStep('shortestPath', args);
+        return this;
+    }
+    /**
+     * Graph traversal sideEffect method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    sideEffect(...args) {
+        this.gremlinLang.addStep('sideEffect', args);
+        return this;
+    }
+    /**
+     * Graph traversal simplePath method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    simplePath(...args) {
+        this.gremlinLang.addStep('simplePath', args);
+        return this;
+    }
+    /**
+     * Graph traversal skip method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    skip(...args) {
+        this.gremlinLang.addStep('skip', args);
+        return this;
+    }
+    /**
+     * Graph traversal split method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    split(...args) {
+        this.gremlinLang.addStep('split', args);
+        return this;
+    }
+    /**
+     * Graph traversal subgraph method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    subgraph(...args) {
+        this.gremlinLang.addStep('subgraph', args);
+        return this;
+    }
+    /**
+     * Graph traversal subgraph method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    substring(...args) {
+        this.gremlinLang.addStep('substring', args);
+        return this;
+    }
+    /**
+     * Graph traversal sum method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    sum(...args) {
+        this.gremlinLang.addStep('sum', args);
+        return this;
+    }
+    /**
+     * Graph traversal tail method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    tail(...args) {
+        this.gremlinLang.addStep('tail', args);
+        return this;
+    }
+    /**
+     * Graph traversal timeLimit method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    timeLimit(...args) {
+        this.gremlinLang.addStep('timeLimit', args);
+        return this;
+    }
+    /**
+     * Graph traversal times method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    times(...args) {
+        this.gremlinLang.addStep('times', args);
+        return this;
+    }
+    /**
+     * Graph traversal to method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    to(...args) {
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] instanceof Vertex) {
+                args[i] = args[i].id;
+            }
+        }
+        this.gremlinLang.addStep('to', args);
+        return this;
+    }
+    /**
+     * Graph traversal toE method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    toE(...args) {
+        this.gremlinLang.addStep('toE', args);
+        return this;
+    }
+    /**
+     * Graph traversal toLower method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    toLower(...args) {
+        this.gremlinLang.addStep('toLower', args);
+        return this;
+    }
+    /**
+     * Graph traversal toUpper method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    toUpper(...args) {
+        this.gremlinLang.addStep('toUpper', args);
+        return this;
+    }
+    /**
+     * Graph traversal toV method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    toV(...args) {
+        this.gremlinLang.addStep('toV', args);
+        return this;
+    }
+    /**
+     * Graph traversal tree method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    tree(...args) {
+        this.gremlinLang.addStep('tree', args);
+        return this;
+    }
+    /**
+     * Graph traversal trim method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    trim(...args) {
+        this.gremlinLang.addStep('trim', args);
+        return this;
+    }
+    /**
+     * Graph traversal unfold method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    unfold(...args) {
+        this.gremlinLang.addStep('unfold', args);
+        return this;
+    }
+    /**
+     * Graph traversal union method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    union(...args) {
+        this.gremlinLang.addStep('union', args);
+        return this;
+    }
+    /**
+     * Graph traversal until method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    until(...args) {
+        this.gremlinLang.addStep('until', args);
+        return this;
+    }
+    /**
+     * Graph traversal value method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    value(...args) {
+        this.gremlinLang.addStep('value', args);
+        return this;
+    }
+    /**
+     * Graph traversal valueMap method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    valueMap(...args) {
+        this.gremlinLang.addStep('valueMap', args);
+        return this;
+    }
+    /**
+     * Graph traversal values method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    values(...args) {
+        this.gremlinLang.addStep('values', args);
+        return this;
+    }
+    /**
+     * Graph traversal where method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    where(...args) {
+        this.gremlinLang.addStep('where', args);
+        return this;
+    }
+    /**
+     * Graph traversal with method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    with_(...args) {
+        this.gremlinLang.addStep('with', args);
+        return this;
+    }
+    /**
+     * Graph traversal write method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    write(...args) {
+        this.gremlinLang.addStep('write', args);
+        return this;
+    }
+}
+export class CardinalityValue extends GremlinLang {
+    /**
+     * Creates a new instance of {@link CardinalityValue}.
+     * @param {String} card
+     * @param {Object} value
+     */
+    constructor(card, value) {
+        super();
+        this.addSource('CardinalityValueTraversal', [card, value]);
+    }
+    /**
+     * Create a value with single cardinality.
+     * @param {Array} value
+     * @returns {CardinalityValue}
+     */
+    static single(value) {
+        return new CardinalityValue(cardinality.single, value);
+    }
+    /**
+     * Create a value with list cardinality.
+     * @param {Array} value
+     * @returns {CardinalityValue}
+     */
+    static list(value) {
+        return new CardinalityValue(cardinality.list, value);
+    }
+    /**
+     * Create a value with set cardinality.
+     * @param {Array} value
+     * @returns {CardinalityValue}
+     */
+    static set(value) {
+        return new CardinalityValue(cardinality.set, value);
+    }
+}
+function callOnEmptyTraversal(fnName, args) {
+    const g = new GraphTraversal(null, null);
+    return g[fnName].apply(g, args);
+}
+/**
+ * Contains the static method definitions
+ */
+export const statics = {
+    E: (...args) => callOnEmptyTraversal('E', args),
+    V: (...args) => callOnEmptyTraversal('V', args),
+    addE: (...args) => callOnEmptyTraversal('addE', args),
+    addV: (...args) => callOnEmptyTraversal('addV', args),
+    aggregate: (...args) => callOnEmptyTraversal('aggregate', args),
+    all: (...args) => callOnEmptyTraversal('all', args),
+    and: (...args) => callOnEmptyTraversal('and', args),
+    any: (...args) => callOnEmptyTraversal('any', args),
+    as: (...args) => callOnEmptyTraversal('as', args),
+    asDate: (...args) => callOnEmptyTraversal('asDate', args),
+    asBool: (...args) => callOnEmptyTraversal('asBool', args),
+    asNumber: (...args) => callOnEmptyTraversal('asNumber', args),
+    asString: (...args) => callOnEmptyTraversal('asString', args),
+    barrier: (...args) => callOnEmptyTraversal('barrier', args),
+    both: (...args) => callOnEmptyTraversal('both', args),
+    bothE: (...args) => callOnEmptyTraversal('bothE', args),
+    bothV: (...args) => callOnEmptyTraversal('bothV', args),
+    branch: (...args) => callOnEmptyTraversal('branch', args),
+    call: (...args) => callOnEmptyTraversal('call', args),
+    cap: (...args) => callOnEmptyTraversal('cap', args),
+    choose: (...args) => callOnEmptyTraversal('choose', args),
+    coalesce: (...args) => callOnEmptyTraversal('coalesce', args),
+    coin: (...args) => callOnEmptyTraversal('coin', args),
+    combine: (...args) => callOnEmptyTraversal('combine', args),
+    concat: (...args) => callOnEmptyTraversal('concat', args),
+    conjoin: (...args) => callOnEmptyTraversal('conjoin', args),
+    constant: (...args) => callOnEmptyTraversal('constant', args),
+    count: (...args) => callOnEmptyTraversal('count', args),
+    cyclicPath: (...args) => callOnEmptyTraversal('cyclicPath', args),
+    dateAdd: (...args) => callOnEmptyTraversal('dateAdd', args),
+    dateDiff: (...args) => callOnEmptyTraversal('dateDiff', args),
+    dedup: (...args) => callOnEmptyTraversal('dedup', args),
+    difference: (...args) => callOnEmptyTraversal('difference', args),
+    discard: (...args) => callOnEmptyTraversal('discard', args),
+    disjunct: (...args) => callOnEmptyTraversal('disjunct', args),
+    drop: (...args) => callOnEmptyTraversal('drop', args),
+    element: (...args) => callOnEmptyTraversal('element', args),
+    elementMap: (...args) => callOnEmptyTraversal('elementMap', args),
+    emit: (...args) => callOnEmptyTraversal('emit', args),
+    fail: (...args) => callOnEmptyTraversal('fail', args),
+    filter: (...args) => callOnEmptyTraversal('filter', args),
+    flatMap: (...args) => callOnEmptyTraversal('flatMap', args),
+    fold: (...args) => callOnEmptyTraversal('fold', args),
+    format: (...args) => callOnEmptyTraversal('format', args),
+    group: (...args) => callOnEmptyTraversal('group', args),
+    groupCount: (...args) => callOnEmptyTraversal('groupCount', args),
+    has: (...args) => callOnEmptyTraversal('has', args),
+    hasId: (...args) => callOnEmptyTraversal('hasId', args),
+    hasKey: (...args) => callOnEmptyTraversal('hasKey', args),
+    hasLabel: (...args) => callOnEmptyTraversal('hasLabel', args),
+    hasNot: (...args) => callOnEmptyTraversal('hasNot', args),
+    hasValue: (...args) => callOnEmptyTraversal('hasValue', args),
+    id: (...args) => callOnEmptyTraversal('id', args),
+    identity: (...args) => callOnEmptyTraversal('identity', args),
+    in_: (...args) => callOnEmptyTraversal('in_', args),
+    inE: (...args) => callOnEmptyTraversal('inE', args),
+    inV: (...args) => callOnEmptyTraversal('inV', args),
+    index: (...args) => callOnEmptyTraversal('index', args),
+    inject: (...args) => callOnEmptyTraversal('inject', args),
+    intersect: (...args) => callOnEmptyTraversal('intersect', args),
+    is: (...args) => callOnEmptyTraversal('is', args),
+    key: (...args) => callOnEmptyTraversal('key', args),
+    label: (...args) => callOnEmptyTraversal('label', args),
+    length: (...args) => callOnEmptyTraversal('length', args),
+    limit: (...args) => callOnEmptyTraversal('limit', args),
+    local: (...args) => callOnEmptyTraversal('local', args),
+    loops: (...args) => callOnEmptyTraversal('loops', args),
+    lTrim: (...args) => callOnEmptyTraversal('lTrim', args),
+    map: (...args) => callOnEmptyTraversal('map', args),
+    match: (...args) => callOnEmptyTraversal('match', args),
+    math: (...args) => callOnEmptyTraversal('math', args),
+    max: (...args) => callOnEmptyTraversal('max', args),
+    mean: (...args) => callOnEmptyTraversal('mean', args),
+    merge: (...args) => callOnEmptyTraversal('merge', args),
+    mergeE: (...args) => callOnEmptyTraversal('mergeE', args),
+    mergeV: (...args) => callOnEmptyTraversal('mergeV', args),
+    min: (...args) => callOnEmptyTraversal('min', args),
+    none: (...args) => callOnEmptyTraversal('none', args),
+    not: (...args) => callOnEmptyTraversal('not', args),
+    optional: (...args) => callOnEmptyTraversal('optional', args),
+    or: (...args) => callOnEmptyTraversal('or', args),
+    order: (...args) => callOnEmptyTraversal('order', args),
+    otherV: (...args) => callOnEmptyTraversal('otherV', args),
+    out: (...args) => callOnEmptyTraversal('out', args),
+    outE: (...args) => callOnEmptyTraversal('outE', args),
+    outV: (...args) => callOnEmptyTraversal('outV', args),
+    path: (...args) => callOnEmptyTraversal('path', args),
+    product: (...args) => callOnEmptyTraversal('product', args),
+    project: (...args) => callOnEmptyTraversal('project', args),
+    properties: (...args) => callOnEmptyTraversal('properties', args),
+    property: (...args) => callOnEmptyTraversal('property', args),
+    propertyMap: (...args) => callOnEmptyTraversal('propertyMap', args),
+    range: (...args) => callOnEmptyTraversal('range', args),
+    repeat: (...args) => callOnEmptyTraversal('repeat', args),
+    replace: (...args) => callOnEmptyTraversal('replace', args),
+    reverse: (...args) => callOnEmptyTraversal('reverse', args),
+    rTrim: (...args) => callOnEmptyTraversal('rTrim', args),
+    sack: (...args) => callOnEmptyTraversal('sack', args),
+    sample: (...args) => callOnEmptyTraversal('sample', args),
+    select: (...args) => callOnEmptyTraversal('select', args),
+    sideEffect: (...args) => callOnEmptyTraversal('sideEffect', args),
+    simplePath: (...args) => callOnEmptyTraversal('simplePath', args),
+    skip: (...args) => callOnEmptyTraversal('skip', args),
+    split: (...args) => callOnEmptyTraversal('split', args),
+    subgraph: (...args) => callOnEmptyTraversal('subgraph', args),
+    substring: (...args) => callOnEmptyTraversal('substring', args),
+    sum: (...args) => callOnEmptyTraversal('sum', args),
+    tail: (...args) => callOnEmptyTraversal('tail', args),
+    timeLimit: (...args) => callOnEmptyTraversal('timeLimit', args),
+    times: (...args) => callOnEmptyTraversal('times', args),
+    to: (...args) => callOnEmptyTraversal('to', args),
+    toE: (...args) => callOnEmptyTraversal('toE', args),
+    toLower: (...args) => callOnEmptyTraversal('toLower', args),
+    toUpper: (...args) => callOnEmptyTraversal('toUpper', args),
+    toV: (...args) => callOnEmptyTraversal('toV', args),
+    tree: (...args) => callOnEmptyTraversal('tree', args),
+    trim: (...args) => callOnEmptyTraversal('trim', args),
+    unfold: (...args) => callOnEmptyTraversal('unfold', args),
+    union: (...args) => callOnEmptyTraversal('union', args),
+    until: (...args) => callOnEmptyTraversal('until', args),
+    value: (...args) => callOnEmptyTraversal('value', args),
+    valueMap: (...args) => callOnEmptyTraversal('valueMap', args),
+    values: (...args) => callOnEmptyTraversal('values', args),
+    where: (...args) => callOnEmptyTraversal('where', args),
+};