gremlin 3.8.1 → 4.0.0-beta.3

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

@@ -0,0 +1,1824 @@
+/*
+ *  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 DriverRemoteConnection from '../driver/driver-remote-connection.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;
+    /** @internal - set by Transaction.begin() for gtx.tx() to return the owning transaction */
+    _boundTransaction;
+    /**
+     * 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() {
+        // If this GTS is already bound to a transaction, return that transaction.
+        if (this._boundTransaction) {
+            return this._boundTransaction;
+        }
+        if (!this.remoteConnection) {
+            throw new Error('Remote connection is required for transactions');
+        }
+        // If the DRC has a transactionId, it was created by a Transaction.begin().
+        // But we don't have the Transaction reference here (only _boundTransaction above).
+        if (this.remoteConnection instanceof DriverRemoteConnection && this.remoteConnection.transactionId) {
+            throw new Error('This TraversalSource is already bound to a transaction - child transactions are not supported');
+        }
+        // Extract the Client from the DriverRemoteConnection.
+        const client = this.remoteConnection._client;
+        return new Transaction(client);
+    }
+    /**
+     * Runs a unit of work inside a transaction, owning the full lifecycle.
+     *
+     * The transaction is begun automatically and the resulting transaction-bound
+     * <code>GraphTraversalSource</code> (<code>gtx</code>) is passed to the
+     * callback as its sole argument. Only <code>gtx</code> is in scope inside the
+     * callback, which avoids accidentally issuing traversals against the
+     * non-transactional <code>g</code>.
+     *
+     * On normal completion of the callback the transaction is committed; on any
+     * abnormal exit (a thrown error or a rejected promise) the transaction is
+     * rolled back. This is a single-shot operation: there is exactly one attempt
+     * (begin -> run -> commit/rollback) and no retry. A second transaction may not
+     * be opened from inside the callback (calling <code>gtx.tx().begin()</code>
+     * throws via the existing double-begin guard).
+     *
+     * The callback may be synchronous or asynchronous; its return value (or the
+     * value its promise resolves to) is awaited and returned from
+     * <code>executeInTx</code>. If the callback returns nothing the result is
+     * <code>undefined</code>.
+     *
+     * Error handling: if the callback throws/rejects, the original error is
+     * re-raised unchanged after rollback is attempted. If the commit itself fails,
+     * the commit error propagates and a rollback is still attempted afterward for
+     * server-side hygiene. In both cases a failed rollback during cleanup is logged
+     * as a warning and never replaces the primary error.
+     *
+     * @param txWork callback that receives the transaction-bound GraphTraversalSource
+     * @returns {Promise<T>} resolves to the callback's value (undefined if none)
+     */
+    async executeInTx(txWork) {
+        const tx = this.tx();
+        const gtx = await tx.begin();
+        let result;
+        // Phase 1: run the user's work. If it throws, roll back and rethrow the body error - the
+        // throw below exits the method, so a failed body never reaches the commit in phase 2.
+        try {
+            result = await txWork(gtx);
+        }
+        catch (bodyError) {
+            try {
+                await tx.rollback();
+            }
+            catch (rollbackError) {
+                console.warn('Rollback failed after transaction body error', rollbackError);
+            }
+            // Re-raise the exact original error; rollback failures never replace it.
+            throw bodyError;
+        }
+        // Phase 2: the body succeeded, so commit. A separate try because this failure mode is
+        // distinct (commit, not body): we still roll back for server hygiene, then rethrow the
+        // commit error as the primary error.
+        try {
+            await tx.commit();
+        }
+        catch (commitError) {
+            try {
+                // Attempt rollback so the server does not keep the transaction around.
+                await tx.rollback();
+            }
+            catch (rollbackError) {
+                console.warn('Rollback failed after commit failure', rollbackError);
+            }
+            // The commit error stays primary; rollback was only for server hygiene.
+            throw commitError;
+        }
+        return result;
+    }
+    /**
+     * @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);
+        // Render multilabel/singlelabel in gremlin text (temporary until these options are removed)
+        if (key === 'multilabel' || key === 'singlelabel') {
+            gl.appendGremlin(`.with("${key}")`);
+        }
+        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);
+    }
+    /**
+     * Spawns a {@link GraphTraversal} by executing a declarative pattern match query.
+     * @param {string} matchQuery - the declarative query string
+     * @param {Record<string, any>} [params] - optional query parameters
+     * @returns {GraphTraversal}
+     */
+    match(matchQuery, params) {
+        const args = params !== undefined ? [matchQuery, params] : [matchQuery];
+        const gl = new GremlinLang(this.gremlinLang).addStep('match', 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 addLabel method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    addLabel(...args) {
+        this.gremlinLang.addStep('addLabel', 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 dropLabel method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    dropLabel(...args) {
+        this.gremlinLang.addStep('dropLabel', args);
+        return this;
+    }
+    /**
+     * Graph traversal dropLabels method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    dropLabels(...args) {
+        this.gremlinLang.addStep('dropLabels', 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 labels method.
+     * @param {...Object} args
+     * @returns {GraphTraversal}
+     */
+    labels(...args) {
+        this.gremlinLang.addStep('labels', 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;
+    }
+    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),
+    addLabel: (...args) => callOnEmptyTraversal('addLabel', 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),
+    dropLabel: (...args) => callOnEmptyTraversal('dropLabel', args),
+    dropLabels: (...args) => callOnEmptyTraversal('dropLabels', 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),
+    labels: (...args) => callOnEmptyTraversal('labels', 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),
+};