gremlin 3.8.1 → 4.0.0-beta.3

package/build/esm/language/translator/JavascriptTranslateVisitor.js

@@ -0,0 +1,225 @@
+/*
+ * 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.
+ */
+// Context parameters are typed as `any` because the generated grammar files
+// use @ts-nocheck (the standard antlr4 npm package doesn't fully re-export
+// its TypeScript types from the main module entry point).
+import TranslateVisitor from './TranslateVisitor.js';
+import { TranslatorException } from './TranslatorException.js';
+/**
+ * Converts a Gremlin traversal string into a JavaScript source code representation.
+ * Assumes use of https://www.npmjs.com/package/uuid library for UUID handling.
+ */
+export default class JavascriptTranslateVisitor extends TranslateVisitor {
+    constructor(graphTraversalSourceName = 'g') {
+        super(graphTraversalSourceName);
+    }
+    processGremlinSymbol(step) {
+        return SymbolHelper.toJavascript(step);
+    }
+    getCardinalityFunctionClass() {
+        return 'CardinalityValue';
+    }
+    visitTraversalStrategy(ctx) {
+        this.sb.push('new ');
+        if (ctx.getChildCount() === 1) {
+            this.sb.push(ctx.getText());
+            this.sb.push('()');
+        }
+        else {
+            const firstText = ctx.getChild(0).getText();
+            const className = firstText === 'new' ? ctx.getChild(1).getText() : firstText;
+            this.sb.push(className);
+            this.sb.push('({');
+            const configs = ctx.configuration();
+            for (let ix = 0; ix < configs.length; ix++) {
+                this.visit(configs[ix]);
+                if (ix < configs.length - 1) {
+                    this.sb.push(', ');
+                }
+            }
+            this.sb.push('})');
+        }
+    }
+    visitConfiguration(ctx) {
+        const keyText = ctx.keyword() != null ? ctx.keyword().getText() : ctx.nakedKey().getText();
+        this.sb.push(SymbolHelper.toJavascript(keyText));
+        this.sb.push(': ');
+        this.visit(ctx.genericArgument());
+    }
+    visitTraversalGType(ctx) {
+        const parts = ctx.getText().split('.');
+        this.sb.push(this.processGremlinSymbol(parts[0]));
+        this.sb.push('.');
+        this.sb.push(this.processGremlinSymbol(parts[1].toLowerCase()));
+    }
+    visitGenericMapLiteral(ctx) {
+        this.sb.push('new Map([');
+        const entries = ctx.mapEntry();
+        for (let i = 0; i < entries.length; i++) {
+            this.visit(entries[i]);
+            if (i < entries.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        this.sb.push('])');
+    }
+    visitMapEntry(ctx) {
+        this.sb.push('[');
+        this.visit(ctx.mapKey());
+        this.sb.push(', ');
+        this.visit(ctx.genericLiteral());
+        this.sb.push(']');
+    }
+    visitMapKey(ctx) {
+        const keyIndex = (ctx.LPAREN() != null && ctx.RPAREN() != null) ? 1 : 0;
+        this.visit(ctx.getChild(keyIndex));
+    }
+    visitDateLiteral(ctx) {
+        // child at index 2 is the string argument to datetime() — comes enclosed in quotes
+        const dtString = ctx.getChild(2).getText();
+        const inner = TranslateVisitor.removeFirstAndLastCharacters(dtString);
+        this.sb.push("new Date('");
+        this.sb.push(formatDatetimeJavaStyle(inner));
+        this.sb.push("')");
+    }
+    visitNanLiteral(_ctx) {
+        this.sb.push('Number.NaN');
+    }
+    visitInfLiteral(ctx) {
+        if (ctx.SignedInfLiteral() != null && ctx.SignedInfLiteral().getText() === '-Infinity') {
+            this.sb.push('Number.NEGATIVE_INFINITY');
+        }
+        else {
+            this.sb.push('Number.POSITIVE_INFINITY');
+        }
+    }
+    visitIntegerLiteral(ctx) {
+        const integerLiteral = ctx.getText().toLowerCase();
+        const lastChar = integerLiteral[integerLiteral.length - 1];
+        if (/[a-z]/.test(lastChar)) {
+            this.sb.push(integerLiteral.slice(0, -1));
+        }
+        else {
+            this.sb.push(integerLiteral);
+        }
+    }
+    visitFloatLiteral(ctx) {
+        if (ctx.infLiteral() != null) {
+            this.visit(ctx.infLiteral());
+            return;
+        }
+        if (ctx.nanLiteral() != null) {
+            this.visit(ctx.nanLiteral());
+            return;
+        }
+        const floatLiteral = ctx.getText().toLowerCase();
+        const lastChar = floatLiteral[floatLiteral.length - 1];
+        if (/[a-z]/.test(lastChar)) {
+            this.sb.push(floatLiteral.slice(0, -1));
+        }
+        else {
+            this.sb.push(floatLiteral);
+        }
+    }
+    visitGenericRangeLiteral(_ctx) {
+        throw new TranslatorException('Javascript does not support range literals');
+    }
+    visitGenericSetLiteral(ctx) {
+        this.sb.push('new Set([');
+        const literals = ctx.genericLiteral();
+        for (let i = 0; i < literals.length; i++) {
+            this.visit(literals[i]);
+            if (i < literals.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        this.sb.push('])');
+    }
+    visitGenericCollectionLiteral(ctx) {
+        this.sb.push('[');
+        const literals = ctx.genericLiteral();
+        for (let i = 0; i < literals.length; i++) {
+            this.visit(literals[i]);
+            if (i < literals.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        this.sb.push(']');
+    }
+    visitUuidLiteral(ctx) {
+        if (ctx.stringLiteral() == null) {
+            this.sb.push('uuid.v4()');
+            return;
+        }
+        this.sb.push('uuid.parse(');
+        this.visitStringLiteral(ctx.stringLiteral());
+        this.sb.push(')');
+    }
+    visitCharacterLiteral(_ctx) {
+        throw new TranslatorException('Character literals are not supported in JavaScript');
+    }
+    visitDurationLiteral(_ctx) {
+        throw new TranslatorException('Duration literals are not supported in JavaScript');
+    }
+    visitBinaryLiteral(ctx) {
+        this.sb.push("Buffer.from(");
+        this.visitStringLiteral(ctx.stringLiteral());
+        this.sb.push(",'base64')");
+    }
+}
+/**
+ * Formats a datetime string the same way Java's OffsetDateTime.toString() does:
+ * - Truncates seconds if both seconds and milliseconds are 0
+ * - Uses 'Z' for UTC offset
+ * - Assumes UTC when no offset is specified
+ */
+function formatDatetimeJavaStyle(s) {
+    const d = new Date(s);
+    if (isNaN(d.getTime())) {
+        throw new TranslatorException(`Invalid datetime: ${s}`);
+    }
+    const year = d.getUTCFullYear().toString().padStart(4, '0');
+    const month = (d.getUTCMonth() + 1).toString().padStart(2, '0');
+    const day = d.getUTCDate().toString().padStart(2, '0');
+    const hours = d.getUTCHours().toString().padStart(2, '0');
+    const minutes = d.getUTCMinutes().toString().padStart(2, '0');
+    const seconds = d.getUTCSeconds();
+    const millis = d.getUTCMilliseconds();
+    let result = `${year}-${month}-${day}T${hours}:${minutes}`;
+    if (seconds !== 0 || millis !== 0) {
+        result += ':' + seconds.toString().padStart(2, '0');
+        if (millis !== 0) {
+            result += '.' + millis.toString().padStart(3, '0').replace(/0+$/, '');
+        }
+    }
+    result += 'Z';
+    return result;
+}
+class SymbolHelper {
+    static TO_JS_MAP = {
+        'from': 'from_',
+        'in': 'in_',
+        'with': 'with_',
+        'bigdecimal': 'bigDecimal',
+        'bigint': 'bigInt',
+    };
+    static toJavascript(symbol) {
+        return SymbolHelper.TO_JS_MAP[symbol] ?? symbol;
+    }
+}

package/build/esm/language/translator/PythonTranslateVisitor.d.ts

@@ -0,0 +1,31 @@
+import TranslateVisitor from './TranslateVisitor.js';
+/**
+ * Converts a Gremlin traversal string into a Python source code representation.
+ * Assumes use of the `uuid` and `datetime` standard library modules.
+ */
+export default class PythonTranslateVisitor extends TranslateVisitor {
+    constructor(graphTraversalSourceName?: string);
+    protected processGremlinSymbol(step: string): string;
+    protected getCardinalityFunctionClass(): string;
+    protected handleStringLiteralText(text: string): void;
+    visitBooleanLiteral(ctx: any): void;
+    visitNullLiteral(_ctx: any): void;
+    visitStringNullableLiteral(ctx: any): void;
+    visitNanLiteral(_ctx: any): void;
+    visitInfLiteral(ctx: any): void;
+    visitIntegerLiteral(ctx: any): void;
+    visitFloatLiteral(ctx: any): void;
+    visitDateLiteral(ctx: any): void;
+    visitGenericRangeLiteral(_ctx: any): void;
+    visitGenericSetLiteral(ctx: any): void;
+    visitGenericCollectionLiteral(ctx: any): void;
+    visitGenericMapLiteral(ctx: any): void;
+    visitMapEntry(ctx: any): void;
+    visitMapKey(ctx: any): void;
+    visitUuidLiteral(ctx: any): void;
+    visitCharacterLiteral(ctx: any): void;
+    visitDurationLiteral(ctx: any): void;
+    visitBinaryLiteral(ctx: any): void;
+    visitTraversalStrategy(ctx: any): void;
+    visitConfiguration(ctx: any): void;
+}

package/build/esm/language/translator/PythonTranslateVisitor.js

@@ -0,0 +1,334 @@
+/*
+ * 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.
+ */
+// Context parameters are typed as `any` because the generated grammar files
+// require accepting arbitrary context types at runtime.
+import TranslateVisitor from './TranslateVisitor.js';
+import { TranslatorException } from './TranslatorException.js';
+/**
+ * Converts a Gremlin traversal string into a Python source code representation.
+ * Assumes use of the `uuid` and `datetime` standard library modules.
+ */
+export default class PythonTranslateVisitor extends TranslateVisitor {
+    constructor(graphTraversalSourceName = 'g') {
+        super(graphTraversalSourceName);
+    }
+    processGremlinSymbol(step) {
+        return SymbolHelper.toPython(step);
+    }
+    getCardinalityFunctionClass() {
+        return 'CardinalityValue';
+    }
+    handleStringLiteralText(text) {
+        if (text.includes("'")) {
+            this.sb.push('"');
+            this.sb.push(text);
+            this.sb.push('"');
+        }
+        else {
+            this.sb.push("'");
+            this.sb.push(text);
+            this.sb.push("'");
+        }
+    }
+    visitBooleanLiteral(ctx) {
+        const text = ctx.getText();
+        this.sb.push(text.charAt(0).toUpperCase() + text.slice(1));
+    }
+    visitNullLiteral(_ctx) {
+        this.sb.push('None');
+    }
+    visitStringNullableLiteral(ctx) {
+        if (ctx.getText() === 'null') {
+            this.sb.push('None');
+        }
+        else {
+            const text = TranslateVisitor.removeFirstAndLastCharacters(ctx.getText());
+            this.handleStringLiteralText(text);
+        }
+    }
+    visitNanLiteral(_ctx) {
+        this.sb.push("float('nan')");
+    }
+    visitInfLiteral(ctx) {
+        if (ctx.SignedInfLiteral() != null && ctx.SignedInfLiteral().getText() === '-Infinity') {
+            this.sb.push("float('-inf')");
+        }
+        else {
+            this.sb.push("float('inf')");
+        }
+    }
+    visitIntegerLiteral(ctx) {
+        const integerLiteral = ctx.getText().toLowerCase();
+        const lastChar = integerLiteral[integerLiteral.length - 1];
+        if (!/[a-z]/.test(lastChar)) {
+            // No type suffix — check if the value exceeds 32-bit signed integer range
+            const value = BigInt(integerLiteral);
+            if (value > BigInt(2147483647) || value < BigInt(-2147483648)) {
+                this.sb.push('long(');
+                this.sb.push(integerLiteral);
+                this.sb.push(')');
+            }
+            else {
+                this.sb.push(integerLiteral);
+            }
+            return;
+        }
+        const num = integerLiteral.slice(0, -1);
+        switch (lastChar) {
+            case 'b':
+            case 's':
+            case 'i':
+                this.sb.push(num);
+                break;
+            case 'n':
+                this.sb.push('bigint(');
+                this.sb.push(num);
+                this.sb.push(')');
+                break;
+            case 'l':
+                this.sb.push('long(');
+                this.sb.push(num);
+                this.sb.push(')');
+                break;
+            default:
+                this.sb.push(integerLiteral);
+                break;
+        }
+    }
+    visitFloatLiteral(ctx) {
+        if (ctx.infLiteral() != null) {
+            this.visit(ctx.infLiteral());
+            return;
+        }
+        if (ctx.nanLiteral() != null) {
+            this.visit(ctx.nanLiteral());
+            return;
+        }
+        const floatLiteral = ctx.getText().toLowerCase();
+        const lastChar = floatLiteral[floatLiteral.length - 1];
+        const num = floatLiteral.slice(0, -1);
+        switch (lastChar) {
+            case 'f':
+            case 'd':
+                this.sb.push(num);
+                break;
+            case 'm':
+                this.sb.push('bigdecimal(');
+                this.sb.push(num);
+                this.sb.push(')');
+                break;
+            default:
+                this.sb.push(floatLiteral);
+                break;
+        }
+    }
+    visitDateLiteral(ctx) {
+        const dtString = ctx.getChild(2).getText();
+        const inner = TranslateVisitor.removeFirstAndLastCharacters(dtString);
+        this.sb.push("datetime.datetime.fromisoformat('");
+        this.sb.push(formatDatetimePythonStyle(inner));
+        this.sb.push("')");
+    }
+    visitGenericRangeLiteral(_ctx) {
+        throw new TranslatorException('Python does not support range literals');
+    }
+    visitGenericSetLiteral(ctx) {
+        const literals = ctx.genericLiteral();
+        if (literals.length === 0) {
+            this.sb.push('set()');
+            return;
+        }
+        this.sb.push('{');
+        for (let i = 0; i < literals.length; i++) {
+            this.visit(literals[i]);
+            if (i < literals.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        this.sb.push('}');
+    }
+    visitGenericCollectionLiteral(ctx) {
+        this.sb.push('[');
+        const literals = ctx.genericLiteral();
+        for (let i = 0; i < literals.length; i++) {
+            this.visit(literals[i]);
+            if (i < literals.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        this.sb.push(']');
+    }
+    visitGenericMapLiteral(ctx) {
+        this.sb.push('{ ');
+        const entries = ctx.mapEntry();
+        for (let i = 0; i < entries.length; i++) {
+            this.visit(entries[i]);
+            if (i < entries.length - 1) {
+                this.sb.push(', ');
+            }
+        }
+        this.sb.push(' }');
+    }
+    visitMapEntry(ctx) {
+        this.visit(ctx.mapKey());
+        this.sb.push(': ');
+        this.visit(ctx.genericLiteral());
+    }
+    visitMapKey(ctx) {
+        const keyIndex = (ctx.LPAREN() != null && ctx.RPAREN() != null) ? 1 : 0;
+        this.visit(ctx.getChild(keyIndex));
+    }
+    visitUuidLiteral(ctx) {
+        if (ctx.stringLiteral() == null) {
+            this.sb.push('uuid.uuid4()');
+            return;
+        }
+        this.sb.push('uuid.UUID(');
+        this.visitStringLiteral(ctx.stringLiteral());
+        this.sb.push(')');
+    }
+    visitCharacterLiteral(ctx) {
+        const text = ctx.getText();
+        const withoutSuffix = text.substring(0, text.length - 1);
+        const inner = TranslateVisitor.removeFirstAndLastCharacters(withoutSuffix);
+        this.sb.push("SingleChar('");
+        this.sb.push(inner);
+        this.sb.push("')");
+    }
+    visitDurationLiteral(ctx) {
+        const seconds = parseInt(ctx.integerLiteral(0).getText(), 10);
+        const nanos = parseInt(ctx.integerLiteral(1).getText(), 10);
+        const isPositive = ctx.booleanLiteral() === null ||
+            ctx.booleanLiteral().getText() === 'true';
+        const totalSeconds = isPositive ? seconds : -seconds;
+        // Python's timedelta has microsecond resolution; sub-microsecond nanos are truncated
+        const micros = Math.floor(nanos / 1000);
+        if (micros === 0) {
+            this.sb.push(`timedelta(seconds=${totalSeconds})`);
+        }
+        else {
+            const totalMicros = isPositive ? micros : -micros;
+            this.sb.push(`timedelta(seconds=${totalSeconds},microseconds=${totalMicros})`);
+        }
+    }
+    visitBinaryLiteral(ctx) {
+        this.sb.push('base64.b64decode(');
+        this.visitStringLiteral(ctx.stringLiteral());
+        this.sb.push(')');
+    }
+    visitTraversalStrategy(ctx) {
+        if (ctx.getChildCount() === 1) {
+            this.sb.push(ctx.getText());
+            this.sb.push('()');
+        }
+        else {
+            const firstText = ctx.getChild(0).getText();
+            const className = firstText === 'new' ? ctx.getChild(1).getText() : firstText;
+            this.sb.push(className);
+            this.sb.push('(');
+            const configs = ctx.configuration();
+            for (let ix = 0; ix < configs.length; ix++) {
+                this.visit(configs[ix]);
+                if (ix < configs.length - 1) {
+                    this.sb.push(', ');
+                }
+            }
+            this.sb.push(')');
+        }
+    }
+    visitConfiguration(ctx) {
+        const keyText = ctx.keyword() != null ? ctx.keyword().getText() : ctx.nakedKey().getText();
+        this.sb.push(SymbolHelper.toPython(keyText));
+        this.sb.push('=');
+        this.visit(ctx.genericArgument());
+    }
+}
+/**
+ * Formats a datetime string for Python's datetime.fromisoformat():
+ * - Truncates seconds if both seconds and milliseconds are 0
+ * - Uses '+00:00' for UTC (Python < 3.11 does not support 'Z')
+ * - Assumes UTC when no offset is specified
+ */
+function formatDatetimePythonStyle(s) {
+    const d = new Date(s);
+    if (isNaN(d.getTime())) {
+        throw new TranslatorException(`Invalid datetime: ${s}`);
+    }
+    const year = d.getUTCFullYear().toString().padStart(4, '0');
+    const month = (d.getUTCMonth() + 1).toString().padStart(2, '0');
+    const day = d.getUTCDate().toString().padStart(2, '0');
+    const hours = d.getUTCHours().toString().padStart(2, '0');
+    const minutes = d.getUTCMinutes().toString().padStart(2, '0');
+    const seconds = d.getUTCSeconds();
+    const millis = d.getUTCMilliseconds();
+    let result = `${year}-${month}-${day}T${hours}:${minutes}`;
+    if (seconds !== 0 || millis !== 0) {
+        result += ':' + seconds.toString().padStart(2, '0');
+        if (millis !== 0) {
+            result += '.' + millis.toString().padStart(3, '0').replace(/0+$/, '');
+        }
+    }
+    result += '+00:00';
+    return result;
+}
+class SymbolHelper {
+    static TO_PYTHON_MAP = {
+        'global': 'global_',
+        'all': 'all_',
+        'and': 'and_',
+        'any': 'any_',
+        'as': 'as_',
+        'filter': 'filter_',
+        'format': 'format_',
+        'from': 'from_',
+        'id': 'id_',
+        'in': 'in_',
+        'is': 'is_',
+        'list': 'list_',
+        'max': 'max_',
+        'min': 'min_',
+        'or': 'or_',
+        'not': 'not_',
+        'range': 'range_',
+        'set': 'set_',
+        'sum': 'sum_',
+        'with': 'with_',
+    };
+    static toPython(symbol) {
+        return SymbolHelper.TO_PYTHON_MAP[symbol] ?? convertCamelCaseToSnakeCase(symbol);
+    }
+}
+function convertCamelCaseToSnakeCase(camelCase) {
+    if (!camelCase)
+        return camelCase;
+    // skip if this is a class/enum indicated by the first letter being upper case
+    if (camelCase.charAt(0) === camelCase.charAt(0).toUpperCase() && /[A-Z]/.test(camelCase.charAt(0))) {
+        return camelCase;
+    }
+    let result = '';
+    for (const c of camelCase) {
+        if (c >= 'A' && c <= 'Z') {
+            result += '_' + c.toLowerCase();
+        }
+        else {
+            result += c;
+        }
+    }
+    return result;
+}

package/build/esm/language/translator/TranslateVisitor.d.ts

@@ -0,0 +1,94 @@
+import { ErrorNode, TerminalNode } from 'antlr4ng';
+/**
+ * Base visitor for translating Gremlin queries. Mirrors the Java TranslateVisitor.
+ * Makes no changes to input except:
+ * - Normalizes whitespace
+ * - Normalizes numeric suffixes to lower case
+ * - Makes anonymous traversals explicit with double underscore
+ * - Makes enums explicit with their proper name
+ */
+export default class TranslateVisitor {
+    protected readonly graphTraversalSourceName: string;
+    protected readonly sb: string[];
+    protected readonly parameters: Set<string>;
+    constructor(graphTraversalSourceName?: string);
+    getTranslated(): string;
+    getParameters(): ReadonlySet<string>;
+    protected processGremlinSymbol(step: string): string;
+    protected appendArgumentSeparator(): void;
+    protected appendStepSeparator(): void;
+    protected appendStepOpen(): void;
+    protected appendStepClose(): void;
+    protected appendAnonymousSpawn(): void;
+    visit(tree: any): void;
+    visitChildren(node: any): void;
+    protected getCardinalityFunctionClass(): string;
+    protected static removeFirstAndLastCharacters(text: string): string;
+    protected handleStringLiteralText(text: string): void;
+    protected appendExplicitNaming(txt: string, prefix: string): void;
+    visitTerminal(node: TerminalNode): void;
+    visitErrorNode(_node: ErrorNode): void;
+    visitTraversalSource(ctx: any): void;
+    visitTraversalSourceSelfMethod(ctx: any): void;
+    visitNestedTraversal(ctx: any): void;
+    visitTraversalScope(ctx: any): void;
+    visitTraversalT(ctx: any): void;
+    visitTraversalTShort(ctx: any): void;
+    visitTraversalTLong(ctx: any): void;
+    visitTraversalMerge(ctx: any): void;
+    visitTraversalOrder(ctx: any): void;
+    visitTraversalBarrier(ctx: any): void;
+    visitTraversalDirection(ctx: any): void;
+    visitTraversalDirectionShort(ctx: any): void;
+    visitTraversalDirectionLong(ctx: any): void;
+    visitTraversalCardinality(ctx: any): void;
+    visitTraversalColumn(ctx: any): void;
+    visitTraversalPop(ctx: any): void;
+    visitTraversalOperator(ctx: any): void;
+    visitTraversalPick(ctx: any): void;
+    visitTraversalDT(ctx: any): void;
+    visitTraversalGType(ctx: any): void;
+    visitTraversalPredicate(ctx: any): void;
+    protected visitP(ctx: any, pClass: string, methodName: string): void;
+    visitTraversalPredicate_eq(ctx: any): void;
+    visitTraversalPredicate_neq(ctx: any): void;
+    visitTraversalPredicate_lt(ctx: any): void;
+    visitTraversalPredicate_lte(ctx: any): void;
+    visitTraversalPredicate_gt(ctx: any): void;
+    visitTraversalPredicate_gte(ctx: any): void;
+    visitTraversalPredicate_inside(ctx: any): void;
+    visitTraversalPredicate_outside(ctx: any): void;
+    visitTraversalPredicate_between(ctx: any): void;
+    visitTraversalPredicate_within(ctx: any): void;
+    visitTraversalPredicate_without(ctx: any): void;
+    visitTraversalPredicate_typeOf(ctx: any): void;
+    visitTraversalPredicate_not(ctx: any): void;
+    visitTraversalPredicate_containing(ctx: any): void;
+    visitTraversalPredicate_notContaining(ctx: any): void;
+    visitTraversalPredicate_startingWith(ctx: any): void;
+    visitTraversalPredicate_notStartingWith(ctx: any): void;
+    visitTraversalPredicate_endingWith(ctx: any): void;
+    visitTraversalPredicate_notEndingWith(ctx: any): void;
+    visitTraversalPredicate_regex(ctx: any): void;
+    visitTraversalPredicate_notRegex(ctx: any): void;
+    visitBooleanArgument(ctx: any): void;
+    visitGenericArgument(ctx: any): void;
+    visitGenericLiteral(ctx: any): void;
+    visitIntegerLiteral(ctx: any): void;
+    visitFloatLiteral(ctx: any): void;
+    visitBooleanLiteral(ctx: any): void;
+    visitNullLiteral(ctx: any): void;
+    visitNanLiteral(ctx: any): void;
+    visitInfLiteral(ctx: any): void;
+    visitUuidLiteral(ctx: any): void;
+    visitCharacterLiteral(ctx: any): void;
+    visitDurationLiteral(ctx: any): void;
+    visitBinaryLiteral(ctx: any): void;
+    visitStringLiteral(ctx: any): void;
+    visitStringNullableLiteral(ctx: any): void;
+    visitNakedKey(ctx: any): void;
+    visitVariable(ctx: any): void;
+    visitKeyword(ctx: any): void;
+    visitMapKey(ctx: any): void;
+    visitMapEntry(ctx: any): void;
+}