spark-sql-language-server 0.0.1-beta.0

package/out-tsc/lib/SparkSqlParserListener.d.ts

@@ -0,0 +1,1089 @@
+import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
+import { TableNameContext } from "./SparkSqlParser";
+import { AliasedQueryContext } from "./SparkSqlParser";
+import { AliasedRelationContext } from "./SparkSqlParser";
+import { InlineTableDefault2Context } from "./SparkSqlParser";
+import { TableValuedFunctionContext } from "./SparkSqlParser";
+import { ExponentLiteralContext } from "./SparkSqlParser";
+import { DecimalLiteralContext } from "./SparkSqlParser";
+import { LegacyDecimalLiteralContext } from "./SparkSqlParser";
+import { IntegerLiteralContext } from "./SparkSqlParser";
+import { BigIntLiteralContext } from "./SparkSqlParser";
+import { SmallIntLiteralContext } from "./SparkSqlParser";
+import { TinyIntLiteralContext } from "./SparkSqlParser";
+import { DoubleLiteralContext } from "./SparkSqlParser";
+import { FloatLiteralContext } from "./SparkSqlParser";
+import { BigDecimalLiteralContext } from "./SparkSqlParser";
+import { QueryTermDefaultContext } from "./SparkSqlParser";
+import { SetOperationContext } from "./SparkSqlParser";
+import { InsertOverwriteTableContext } from "./SparkSqlParser";
+import { InsertIntoTableContext } from "./SparkSqlParser";
+import { InsertIntoReplaceWhereContext } from "./SparkSqlParser";
+import { InsertOverwriteHiveDirContext } from "./SparkSqlParser";
+import { InsertOverwriteDirContext } from "./SparkSqlParser";
+import { ValueExpressionDefaultContext } from "./SparkSqlParser";
+import { ArithmeticUnaryContext } from "./SparkSqlParser";
+import { ArithmeticBinaryContext } from "./SparkSqlParser";
+import { ComparisonContext } from "./SparkSqlParser";
+import { PartitionTransformContext } from "./SparkSqlParser";
+import { PartitionColumnContext } from "./SparkSqlParser";
+import { QueryPrimaryDefaultContext } from "./SparkSqlParser";
+import { FromStmtContext } from "./SparkSqlParser";
+import { TableContext } from "./SparkSqlParser";
+import { InlineTableDefault1Context } from "./SparkSqlParser";
+import { SubqueryContext } from "./SparkSqlParser";
+import { SingleInsertQueryContext } from "./SparkSqlParser";
+import { MultiInsertQueryContext } from "./SparkSqlParser";
+import { DeleteFromTableContext } from "./SparkSqlParser";
+import { UpdateTableContext } from "./SparkSqlParser";
+import { MergeIntoTableContext } from "./SparkSqlParser";
+import { CurrentLikeContext } from "./SparkSqlParser";
+import { TimestampaddContext } from "./SparkSqlParser";
+import { TimestampdiffContext } from "./SparkSqlParser";
+import { SearchedCaseContext } from "./SparkSqlParser";
+import { SimpleCaseContext } from "./SparkSqlParser";
+import { CastContext } from "./SparkSqlParser";
+import { StructContext } from "./SparkSqlParser";
+import { FirstContext } from "./SparkSqlParser";
+import { Any_valueContext } from "./SparkSqlParser";
+import { LastContext } from "./SparkSqlParser";
+import { PositionContext } from "./SparkSqlParser";
+import { ConstantDefaultContext } from "./SparkSqlParser";
+import { StarContext } from "./SparkSqlParser";
+import { RowConstructorContext } from "./SparkSqlParser";
+import { SubqueryExpressionContext } from "./SparkSqlParser";
+import { IdentifierClauseContext } from "./SparkSqlParser";
+import { FunctionCallContext } from "./SparkSqlParser";
+import { LambdaContext } from "./SparkSqlParser";
+import { SubscriptContext } from "./SparkSqlParser";
+import { ColumnReferenceContext } from "./SparkSqlParser";
+import { DereferenceContext } from "./SparkSqlParser";
+import { ParenthesizedExpressionContext } from "./SparkSqlParser";
+import { ExtractContext } from "./SparkSqlParser";
+import { SubstringContext } from "./SparkSqlParser";
+import { TrimContext } from "./SparkSqlParser";
+import { OverlayContext } from "./SparkSqlParser";
+import { PercentileContext } from "./SparkSqlParser";
+import { UnquotedIdentifierContext } from "./SparkSqlParser";
+import { QuotedIdentifierAlternativeContext } from "./SparkSqlParser";
+import { TableFileFormatContext } from "./SparkSqlParser";
+import { GenericFileFormatContext } from "./SparkSqlParser";
+import { SampleByPercentileContext } from "./SparkSqlParser";
+import { SampleByRowsContext } from "./SparkSqlParser";
+import { SampleByBucketContext } from "./SparkSqlParser";
+import { SampleByBytesContext } from "./SparkSqlParser";
+import { NullLiteralContext } from "./SparkSqlParser";
+import { PosParameterLiteralContext } from "./SparkSqlParser";
+import { NamedParameterLiteralContext } from "./SparkSqlParser";
+import { IntervalLiteralContext } from "./SparkSqlParser";
+import { TypeConstructorContext } from "./SparkSqlParser";
+import { NumericLiteralContext } from "./SparkSqlParser";
+import { BooleanLiteralContext } from "./SparkSqlParser";
+import { StringLiteralContext } from "./SparkSqlParser";
+import { RowFormatSerdeContext } from "./SparkSqlParser";
+import { RowFormatDelimitedContext } from "./SparkSqlParser";
+import { ComplexDataTypeContext } from "./SparkSqlParser";
+import { YearMonthIntervalDataTypeContext } from "./SparkSqlParser";
+import { DayTimeIntervalDataTypeContext } from "./SparkSqlParser";
+import { PrimitiveDataTypeContext } from "./SparkSqlParser";
+import { TransformQuerySpecificationContext } from "./SparkSqlParser";
+import { RegularQuerySpecificationContext } from "./SparkSqlParser";
+import { ErrorIdentContext } from "./SparkSqlParser";
+import { RealIdentContext } from "./SparkSqlParser";
+import { WindowRefContext } from "./SparkSqlParser";
+import { WindowDefContext } from "./SparkSqlParser";
+import { IdentityTransformContext } from "./SparkSqlParser";
+import { ApplyTransformContext } from "./SparkSqlParser";
+import { StatementDefaultContext } from "./SparkSqlParser";
+import { DmlStatementContext } from "./SparkSqlParser";
+import { UseContext } from "./SparkSqlParser";
+import { UseNamespaceContext } from "./SparkSqlParser";
+import { SetCatalogContext } from "./SparkSqlParser";
+import { CreateNamespaceContext } from "./SparkSqlParser";
+import { SetNamespacePropertiesContext } from "./SparkSqlParser";
+import { SetNamespaceLocationContext } from "./SparkSqlParser";
+import { DropNamespaceContext } from "./SparkSqlParser";
+import { ShowNamespacesContext } from "./SparkSqlParser";
+import { CreateTableContext } from "./SparkSqlParser";
+import { CreateTableLikeContext } from "./SparkSqlParser";
+import { ReplaceTableContext } from "./SparkSqlParser";
+import { AnalyzeContext } from "./SparkSqlParser";
+import { AnalyzeTablesContext } from "./SparkSqlParser";
+import { AddTableColumnsContext } from "./SparkSqlParser";
+import { RenameTableColumnContext } from "./SparkSqlParser";
+import { DropTableColumnsContext } from "./SparkSqlParser";
+import { RenameTableContext } from "./SparkSqlParser";
+import { SetTablePropertiesContext } from "./SparkSqlParser";
+import { UnsetTablePropertiesContext } from "./SparkSqlParser";
+import { AlterTableAlterColumnContext } from "./SparkSqlParser";
+import { HiveChangeColumnContext } from "./SparkSqlParser";
+import { HiveReplaceColumnsContext } from "./SparkSqlParser";
+import { SetTableSerDeContext } from "./SparkSqlParser";
+import { AddTablePartitionContext } from "./SparkSqlParser";
+import { RenameTablePartitionContext } from "./SparkSqlParser";
+import { DropTablePartitionsContext } from "./SparkSqlParser";
+import { SetTableLocationContext } from "./SparkSqlParser";
+import { RecoverPartitionsContext } from "./SparkSqlParser";
+import { DropTableContext } from "./SparkSqlParser";
+import { DropViewContext } from "./SparkSqlParser";
+import { CreateViewContext } from "./SparkSqlParser";
+import { CreateTempViewUsingContext } from "./SparkSqlParser";
+import { AlterViewQueryContext } from "./SparkSqlParser";
+import { CreateFunctionContext } from "./SparkSqlParser";
+import { DropFunctionContext } from "./SparkSqlParser";
+import { ExplainContext } from "./SparkSqlParser";
+import { ShowTablesContext } from "./SparkSqlParser";
+import { ShowTableExtendedContext } from "./SparkSqlParser";
+import { ShowTblPropertiesContext } from "./SparkSqlParser";
+import { ShowColumnsContext } from "./SparkSqlParser";
+import { ShowViewsContext } from "./SparkSqlParser";
+import { ShowPartitionsContext } from "./SparkSqlParser";
+import { ShowFunctionsContext } from "./SparkSqlParser";
+import { ShowCreateTableContext } from "./SparkSqlParser";
+import { ShowCurrentNamespaceContext } from "./SparkSqlParser";
+import { ShowCatalogsContext } from "./SparkSqlParser";
+import { DescribeFunctionContext } from "./SparkSqlParser";
+import { DescribeNamespaceContext } from "./SparkSqlParser";
+import { DescribeRelationContext } from "./SparkSqlParser";
+import { DescribeQueryContext } from "./SparkSqlParser";
+import { CommentNamespaceContext } from "./SparkSqlParser";
+import { CommentTableContext } from "./SparkSqlParser";
+import { RefreshTableContext } from "./SparkSqlParser";
+import { RefreshFunctionContext } from "./SparkSqlParser";
+import { RefreshResourceContext } from "./SparkSqlParser";
+import { CacheTableContext } from "./SparkSqlParser";
+import { UncacheTableContext } from "./SparkSqlParser";
+import { ClearCacheContext } from "./SparkSqlParser";
+import { LoadDataContext } from "./SparkSqlParser";
+import { TruncateTableContext } from "./SparkSqlParser";
+import { RepairTableContext } from "./SparkSqlParser";
+import { ManageResourceContext } from "./SparkSqlParser";
+import { FailNativeCommandContext } from "./SparkSqlParser";
+import { SetTimeZoneContext } from "./SparkSqlParser";
+import { SetQuotedConfigurationContext } from "./SparkSqlParser";
+import { SetConfigurationContext } from "./SparkSqlParser";
+import { ResetQuotedConfigurationContext } from "./SparkSqlParser";
+import { ResetConfigurationContext } from "./SparkSqlParser";
+import { CreateIndexContext } from "./SparkSqlParser";
+import { DropIndexContext } from "./SparkSqlParser";
+import { LogicalNotContext } from "./SparkSqlParser";
+import { ExistsContext } from "./SparkSqlParser";
+import { PredicatedContext } from "./SparkSqlParser";
+import { LogicalBinaryContext } from "./SparkSqlParser";
+import { ProgramContext } from "./SparkSqlParser";
+import { StatementsContext } from "./SparkSqlParser";
+import { StatementEndContext } from "./SparkSqlParser";
+import { SingleStatementContext } from "./SparkSqlParser";
+import { SingleExpressionContext } from "./SparkSqlParser";
+import { SingleTableIdentifierContext } from "./SparkSqlParser";
+import { SingleMultipartIdentifierContext } from "./SparkSqlParser";
+import { SingleFunctionIdentifierContext } from "./SparkSqlParser";
+import { SingleDataTypeContext } from "./SparkSqlParser";
+import { SingleTableSchemaContext } from "./SparkSqlParser";
+import { StatementForFoldingContext } from "./SparkSqlParser";
+import { StatementContext } from "./SparkSqlParser";
+import { TimezoneContext } from "./SparkSqlParser";
+import { ConfigKeyContext } from "./SparkSqlParser";
+import { ConfigValueContext } from "./SparkSqlParser";
+import { UnsupportedHiveNativeCommandsContext } from "./SparkSqlParser";
+import { CreateTableHeaderContext } from "./SparkSqlParser";
+import { ReplaceTableHeaderContext } from "./SparkSqlParser";
+import { BucketSpecContext } from "./SparkSqlParser";
+import { SkewSpecContext } from "./SparkSqlParser";
+import { LocationSpecContext } from "./SparkSqlParser";
+import { CommentSpecContext } from "./SparkSqlParser";
+import { QueryContext } from "./SparkSqlParser";
+import { InsertIntoContext } from "./SparkSqlParser";
+import { PartitionSpecLocationContext } from "./SparkSqlParser";
+import { PartitionSpecContext } from "./SparkSqlParser";
+import { PartitionValContext } from "./SparkSqlParser";
+import { NamespaceContext } from "./SparkSqlParser";
+import { NamespacesContext } from "./SparkSqlParser";
+import { DescribeFuncNameContext } from "./SparkSqlParser";
+import { DescribeColNameContext } from "./SparkSqlParser";
+import { CtesContext } from "./SparkSqlParser";
+import { NamedQueryContext } from "./SparkSqlParser";
+import { TableProviderContext } from "./SparkSqlParser";
+import { CreateTableClausesContext } from "./SparkSqlParser";
+import { PropertyListContext } from "./SparkSqlParser";
+import { PropertyContext } from "./SparkSqlParser";
+import { PropertyKeyContext } from "./SparkSqlParser";
+import { PropertyValueContext } from "./SparkSqlParser";
+import { ExpressionPropertyListContext } from "./SparkSqlParser";
+import { ExpressionPropertyContext } from "./SparkSqlParser";
+import { ConstantListContext } from "./SparkSqlParser";
+import { NestedConstantListContext } from "./SparkSqlParser";
+import { CreateFileFormatContext } from "./SparkSqlParser";
+import { FileFormatContext } from "./SparkSqlParser";
+import { StorageHandlerContext } from "./SparkSqlParser";
+import { ResourceContext } from "./SparkSqlParser";
+import { DmlStatementNoWithContext } from "./SparkSqlParser";
+import { IdentifierReferenceContext } from "./SparkSqlParser";
+import { QueryOrganizationContext } from "./SparkSqlParser";
+import { MultiInsertQueryBodyContext } from "./SparkSqlParser";
+import { QueryTermContext } from "./SparkSqlParser";
+import { QueryPrimaryContext } from "./SparkSqlParser";
+import { SortItemContext } from "./SparkSqlParser";
+import { FromStatementContext } from "./SparkSqlParser";
+import { FromStatementBodyContext } from "./SparkSqlParser";
+import { QuerySpecificationContext } from "./SparkSqlParser";
+import { TransformClauseContext } from "./SparkSqlParser";
+import { SelectClauseContext } from "./SparkSqlParser";
+import { SetClauseContext } from "./SparkSqlParser";
+import { MatchedClauseContext } from "./SparkSqlParser";
+import { NotMatchedClauseContext } from "./SparkSqlParser";
+import { NotMatchedBySourceClauseContext } from "./SparkSqlParser";
+import { MatchedActionContext } from "./SparkSqlParser";
+import { NotMatchedActionContext } from "./SparkSqlParser";
+import { NotMatchedBySourceActionContext } from "./SparkSqlParser";
+import { AssignmentListContext } from "./SparkSqlParser";
+import { AssignmentContext } from "./SparkSqlParser";
+import { WhereClauseContext } from "./SparkSqlParser";
+import { HavingClauseContext } from "./SparkSqlParser";
+import { HintContext } from "./SparkSqlParser";
+import { HintStatementContext } from "./SparkSqlParser";
+import { FromClauseContext } from "./SparkSqlParser";
+import { TemporalClauseContext } from "./SparkSqlParser";
+import { AggregationClauseContext } from "./SparkSqlParser";
+import { GroupByClauseContext } from "./SparkSqlParser";
+import { GroupingAnalyticsContext } from "./SparkSqlParser";
+import { GroupingElementContext } from "./SparkSqlParser";
+import { GroupingSetContext } from "./SparkSqlParser";
+import { PivotClauseContext } from "./SparkSqlParser";
+import { PivotColumnContext } from "./SparkSqlParser";
+import { PivotValueContext } from "./SparkSqlParser";
+import { UnpivotClauseContext } from "./SparkSqlParser";
+import { UnpivotNullClauseContext } from "./SparkSqlParser";
+import { UnpivotOperatorContext } from "./SparkSqlParser";
+import { UnpivotSingleValueColumnClauseContext } from "./SparkSqlParser";
+import { UnpivotMultiValueColumnClauseContext } from "./SparkSqlParser";
+import { UnpivotColumnSetContext } from "./SparkSqlParser";
+import { UnpivotValueColumnContext } from "./SparkSqlParser";
+import { UnpivotNameColumnContext } from "./SparkSqlParser";
+import { UnpivotColumnAndAliasContext } from "./SparkSqlParser";
+import { UnpivotColumnContext } from "./SparkSqlParser";
+import { UnpivotAliasContext } from "./SparkSqlParser";
+import { LateralViewContext } from "./SparkSqlParser";
+import { SetQuantifierContext } from "./SparkSqlParser";
+import { RelationContext } from "./SparkSqlParser";
+import { RelationExtensionContext } from "./SparkSqlParser";
+import { JoinRelationContext } from "./SparkSqlParser";
+import { JoinTypeContext } from "./SparkSqlParser";
+import { JoinCriteriaContext } from "./SparkSqlParser";
+import { SampleContext } from "./SparkSqlParser";
+import { SampleMethodContext } from "./SparkSqlParser";
+import { IdentifierListContext } from "./SparkSqlParser";
+import { IdentifierSeqContext } from "./SparkSqlParser";
+import { OrderedIdentifierListContext } from "./SparkSqlParser";
+import { OrderedIdentifierContext } from "./SparkSqlParser";
+import { IdentifierCommentListContext } from "./SparkSqlParser";
+import { IdentifierCommentContext } from "./SparkSqlParser";
+import { RelationPrimaryContext } from "./SparkSqlParser";
+import { InlineTableContext } from "./SparkSqlParser";
+import { FunctionTableSubqueryArgumentContext } from "./SparkSqlParser";
+import { TableArgumentPartitioningContext } from "./SparkSqlParser";
+import { FunctionTableNamedArgumentExpressionContext } from "./SparkSqlParser";
+import { FunctionTableReferenceArgumentContext } from "./SparkSqlParser";
+import { FunctionTableArgumentContext } from "./SparkSqlParser";
+import { FunctionTableContext } from "./SparkSqlParser";
+import { TableAliasContext } from "./SparkSqlParser";
+import { RowFormatContext } from "./SparkSqlParser";
+import { MultipartIdentifierListContext } from "./SparkSqlParser";
+import { MultipartIdentifierContext } from "./SparkSqlParser";
+import { MultipartIdentifierPropertyListContext } from "./SparkSqlParser";
+import { MultipartIdentifierPropertyContext } from "./SparkSqlParser";
+import { TableIdentifierContext } from "./SparkSqlParser";
+import { FunctionIdentifierContext } from "./SparkSqlParser";
+import { NamedExpressionContext } from "./SparkSqlParser";
+import { NamedExpressionSeqContext } from "./SparkSqlParser";
+import { PartitionFieldListContext } from "./SparkSqlParser";
+import { PartitionFieldContext } from "./SparkSqlParser";
+import { TransformContext } from "./SparkSqlParser";
+import { TransformArgumentContext } from "./SparkSqlParser";
+import { ExpressionContext } from "./SparkSqlParser";
+import { NamedArgumentExpressionContext } from "./SparkSqlParser";
+import { FunctionArgumentContext } from "./SparkSqlParser";
+import { ExpressionSeqContext } from "./SparkSqlParser";
+import { BooleanExpressionContext } from "./SparkSqlParser";
+import { PredicateContext } from "./SparkSqlParser";
+import { ValueExpressionContext } from "./SparkSqlParser";
+import { DatetimeUnitContext } from "./SparkSqlParser";
+import { PrimaryExpressionContext } from "./SparkSqlParser";
+import { LiteralTypeContext } from "./SparkSqlParser";
+import { ConstantContext } from "./SparkSqlParser";
+import { ComparisonOperatorContext } from "./SparkSqlParser";
+import { ArithmeticOperatorContext } from "./SparkSqlParser";
+import { PredicateOperatorContext } from "./SparkSqlParser";
+import { BooleanValueContext } from "./SparkSqlParser";
+import { IntervalContext } from "./SparkSqlParser";
+import { ErrorCapturingMultiUnitsIntervalContext } from "./SparkSqlParser";
+import { MultiUnitsIntervalContext } from "./SparkSqlParser";
+import { ErrorCapturingUnitToUnitIntervalContext } from "./SparkSqlParser";
+import { UnitToUnitIntervalContext } from "./SparkSqlParser";
+import { IntervalValueContext } from "./SparkSqlParser";
+import { UnitInMultiUnitsContext } from "./SparkSqlParser";
+import { UnitInUnitToUnitContext } from "./SparkSqlParser";
+import { ColPositionContext } from "./SparkSqlParser";
+import { TypeContext } from "./SparkSqlParser";
+import { DataTypeContext } from "./SparkSqlParser";
+import { QualifiedColTypeWithPositionListContext } from "./SparkSqlParser";
+import { QualifiedColTypeWithPositionContext } from "./SparkSqlParser";
+import { ColDefinitionDescriptorWithPositionContext } from "./SparkSqlParser";
+import { DefaultExpressionContext } from "./SparkSqlParser";
+import { ColTypeListContext } from "./SparkSqlParser";
+import { ColTypeContext } from "./SparkSqlParser";
+import { CreateOrReplaceTableColTypeListContext } from "./SparkSqlParser";
+import { CreateOrReplaceTableColTypeContext } from "./SparkSqlParser";
+import { ColDefinitionOptionContext } from "./SparkSqlParser";
+import { GenerationExpressionContext } from "./SparkSqlParser";
+import { ComplexColTypeListContext } from "./SparkSqlParser";
+import { ComplexColTypeContext } from "./SparkSqlParser";
+import { WhenClauseContext } from "./SparkSqlParser";
+import { WindowClauseContext } from "./SparkSqlParser";
+import { NamedWindowContext } from "./SparkSqlParser";
+import { WindowSpecContext } from "./SparkSqlParser";
+import { WindowFrameContext } from "./SparkSqlParser";
+import { FrameBoundContext } from "./SparkSqlParser";
+import { QualifiedNameListContext } from "./SparkSqlParser";
+import { FunctionNameContext } from "./SparkSqlParser";
+import { QualifiedNameContext } from "./SparkSqlParser";
+import { ErrorCapturingIdentifierContext } from "./SparkSqlParser";
+import { ErrorCapturingIdentifierExtraContext } from "./SparkSqlParser";
+import { IdentifierContext } from "./SparkSqlParser";
+import { StrictIdentifierContext } from "./SparkSqlParser";
+import { QuotedIdentifierContext } from "./SparkSqlParser";
+import { BackQuotedIdentifierContext } from "./SparkSqlParser";
+import { NumberContext } from "./SparkSqlParser";
+import { AlterColumnActionContext } from "./SparkSqlParser";
+import { StringLitContext } from "./SparkSqlParser";
+import { CommentContext } from "./SparkSqlParser";
+import { VersionContext } from "./SparkSqlParser";
+import { AnsiNonReservedContext } from "./SparkSqlParser";
+import { StrictNonReservedContext } from "./SparkSqlParser";
+import { NonReservedContext } from "./SparkSqlParser";
+export interface SparkSqlParserListener extends ParseTreeListener {
+    enterTableName?: (ctx: TableNameContext) => void;
+    exitTableName?: (ctx: TableNameContext) => void;
+    enterAliasedQuery?: (ctx: AliasedQueryContext) => void;
+    exitAliasedQuery?: (ctx: AliasedQueryContext) => void;
+    enterAliasedRelation?: (ctx: AliasedRelationContext) => void;
+    exitAliasedRelation?: (ctx: AliasedRelationContext) => void;
+    enterInlineTableDefault2?: (ctx: InlineTableDefault2Context) => void;
+    exitInlineTableDefault2?: (ctx: InlineTableDefault2Context) => void;
+    enterTableValuedFunction?: (ctx: TableValuedFunctionContext) => void;
+    exitTableValuedFunction?: (ctx: TableValuedFunctionContext) => void;
+    enterExponentLiteral?: (ctx: ExponentLiteralContext) => void;
+    exitExponentLiteral?: (ctx: ExponentLiteralContext) => void;
+    enterDecimalLiteral?: (ctx: DecimalLiteralContext) => void;
+    exitDecimalLiteral?: (ctx: DecimalLiteralContext) => void;
+    enterLegacyDecimalLiteral?: (ctx: LegacyDecimalLiteralContext) => void;
+    exitLegacyDecimalLiteral?: (ctx: LegacyDecimalLiteralContext) => void;
+    enterIntegerLiteral?: (ctx: IntegerLiteralContext) => void;
+    exitIntegerLiteral?: (ctx: IntegerLiteralContext) => void;
+    enterBigIntLiteral?: (ctx: BigIntLiteralContext) => void;
+    exitBigIntLiteral?: (ctx: BigIntLiteralContext) => void;
+    enterSmallIntLiteral?: (ctx: SmallIntLiteralContext) => void;
+    exitSmallIntLiteral?: (ctx: SmallIntLiteralContext) => void;
+    enterTinyIntLiteral?: (ctx: TinyIntLiteralContext) => void;
+    exitTinyIntLiteral?: (ctx: TinyIntLiteralContext) => void;
+    enterDoubleLiteral?: (ctx: DoubleLiteralContext) => void;
+    exitDoubleLiteral?: (ctx: DoubleLiteralContext) => void;
+    enterFloatLiteral?: (ctx: FloatLiteralContext) => void;
+    exitFloatLiteral?: (ctx: FloatLiteralContext) => void;
+    enterBigDecimalLiteral?: (ctx: BigDecimalLiteralContext) => void;
+    exitBigDecimalLiteral?: (ctx: BigDecimalLiteralContext) => void;
+    enterQueryTermDefault?: (ctx: QueryTermDefaultContext) => void;
+    exitQueryTermDefault?: (ctx: QueryTermDefaultContext) => void;
+    enterSetOperation?: (ctx: SetOperationContext) => void;
+    exitSetOperation?: (ctx: SetOperationContext) => void;
+    enterInsertOverwriteTable?: (ctx: InsertOverwriteTableContext) => void;
+    exitInsertOverwriteTable?: (ctx: InsertOverwriteTableContext) => void;
+    enterInsertIntoTable?: (ctx: InsertIntoTableContext) => void;
+    exitInsertIntoTable?: (ctx: InsertIntoTableContext) => void;
+    enterInsertIntoReplaceWhere?: (ctx: InsertIntoReplaceWhereContext) => void;
+    exitInsertIntoReplaceWhere?: (ctx: InsertIntoReplaceWhereContext) => void;
+    enterInsertOverwriteHiveDir?: (ctx: InsertOverwriteHiveDirContext) => void;
+    exitInsertOverwriteHiveDir?: (ctx: InsertOverwriteHiveDirContext) => void;
+    enterInsertOverwriteDir?: (ctx: InsertOverwriteDirContext) => void;
+    exitInsertOverwriteDir?: (ctx: InsertOverwriteDirContext) => void;
+    enterValueExpressionDefault?: (ctx: ValueExpressionDefaultContext) => void;
+    exitValueExpressionDefault?: (ctx: ValueExpressionDefaultContext) => void;
+    enterArithmeticUnary?: (ctx: ArithmeticUnaryContext) => void;
+    exitArithmeticUnary?: (ctx: ArithmeticUnaryContext) => void;
+    enterArithmeticBinary?: (ctx: ArithmeticBinaryContext) => void;
+    exitArithmeticBinary?: (ctx: ArithmeticBinaryContext) => void;
+    enterComparison?: (ctx: ComparisonContext) => void;
+    exitComparison?: (ctx: ComparisonContext) => void;
+    enterPartitionTransform?: (ctx: PartitionTransformContext) => void;
+    exitPartitionTransform?: (ctx: PartitionTransformContext) => void;
+    enterPartitionColumn?: (ctx: PartitionColumnContext) => void;
+    exitPartitionColumn?: (ctx: PartitionColumnContext) => void;
+    enterQueryPrimaryDefault?: (ctx: QueryPrimaryDefaultContext) => void;
+    exitQueryPrimaryDefault?: (ctx: QueryPrimaryDefaultContext) => void;
+    enterFromStmt?: (ctx: FromStmtContext) => void;
+    exitFromStmt?: (ctx: FromStmtContext) => void;
+    enterTable?: (ctx: TableContext) => void;
+    exitTable?: (ctx: TableContext) => void;
+    enterInlineTableDefault1?: (ctx: InlineTableDefault1Context) => void;
+    exitInlineTableDefault1?: (ctx: InlineTableDefault1Context) => void;
+    enterSubquery?: (ctx: SubqueryContext) => void;
+    exitSubquery?: (ctx: SubqueryContext) => void;
+    enterSingleInsertQuery?: (ctx: SingleInsertQueryContext) => void;
+    exitSingleInsertQuery?: (ctx: SingleInsertQueryContext) => void;
+    enterMultiInsertQuery?: (ctx: MultiInsertQueryContext) => void;
+    exitMultiInsertQuery?: (ctx: MultiInsertQueryContext) => void;
+    enterDeleteFromTable?: (ctx: DeleteFromTableContext) => void;
+    exitDeleteFromTable?: (ctx: DeleteFromTableContext) => void;
+    enterUpdateTable?: (ctx: UpdateTableContext) => void;
+    exitUpdateTable?: (ctx: UpdateTableContext) => void;
+    enterMergeIntoTable?: (ctx: MergeIntoTableContext) => void;
+    exitMergeIntoTable?: (ctx: MergeIntoTableContext) => void;
+    enterCurrentLike?: (ctx: CurrentLikeContext) => void;
+    exitCurrentLike?: (ctx: CurrentLikeContext) => void;
+    enterTimestampadd?: (ctx: TimestampaddContext) => void;
+    exitTimestampadd?: (ctx: TimestampaddContext) => void;
+    enterTimestampdiff?: (ctx: TimestampdiffContext) => void;
+    exitTimestampdiff?: (ctx: TimestampdiffContext) => void;
+    enterSearchedCase?: (ctx: SearchedCaseContext) => void;
+    exitSearchedCase?: (ctx: SearchedCaseContext) => void;
+    enterSimpleCase?: (ctx: SimpleCaseContext) => void;
+    exitSimpleCase?: (ctx: SimpleCaseContext) => void;
+    enterCast?: (ctx: CastContext) => void;
+    exitCast?: (ctx: CastContext) => void;
+    enterStruct?: (ctx: StructContext) => void;
+    exitStruct?: (ctx: StructContext) => void;
+    enterFirst?: (ctx: FirstContext) => void;
+    exitFirst?: (ctx: FirstContext) => void;
+    enterAny_value?: (ctx: Any_valueContext) => void;
+    exitAny_value?: (ctx: Any_valueContext) => void;
+    enterLast?: (ctx: LastContext) => void;
+    exitLast?: (ctx: LastContext) => void;
+    enterPosition?: (ctx: PositionContext) => void;
+    exitPosition?: (ctx: PositionContext) => void;
+    enterConstantDefault?: (ctx: ConstantDefaultContext) => void;
+    exitConstantDefault?: (ctx: ConstantDefaultContext) => void;
+    enterStar?: (ctx: StarContext) => void;
+    exitStar?: (ctx: StarContext) => void;
+    enterRowConstructor?: (ctx: RowConstructorContext) => void;
+    exitRowConstructor?: (ctx: RowConstructorContext) => void;
+    enterSubqueryExpression?: (ctx: SubqueryExpressionContext) => void;
+    exitSubqueryExpression?: (ctx: SubqueryExpressionContext) => void;
+    enterIdentifierClause?: (ctx: IdentifierClauseContext) => void;
+    exitIdentifierClause?: (ctx: IdentifierClauseContext) => void;
+    enterFunctionCall?: (ctx: FunctionCallContext) => void;
+    exitFunctionCall?: (ctx: FunctionCallContext) => void;
+    enterLambda?: (ctx: LambdaContext) => void;
+    exitLambda?: (ctx: LambdaContext) => void;
+    enterSubscript?: (ctx: SubscriptContext) => void;
+    exitSubscript?: (ctx: SubscriptContext) => void;
+    enterColumnReference?: (ctx: ColumnReferenceContext) => void;
+    exitColumnReference?: (ctx: ColumnReferenceContext) => void;
+    enterDereference?: (ctx: DereferenceContext) => void;
+    exitDereference?: (ctx: DereferenceContext) => void;
+    enterParenthesizedExpression?: (ctx: ParenthesizedExpressionContext) => void;
+    exitParenthesizedExpression?: (ctx: ParenthesizedExpressionContext) => void;
+    enterExtract?: (ctx: ExtractContext) => void;
+    exitExtract?: (ctx: ExtractContext) => void;
+    enterSubstring?: (ctx: SubstringContext) => void;
+    exitSubstring?: (ctx: SubstringContext) => void;
+    enterTrim?: (ctx: TrimContext) => void;
+    exitTrim?: (ctx: TrimContext) => void;
+    enterOverlay?: (ctx: OverlayContext) => void;
+    exitOverlay?: (ctx: OverlayContext) => void;
+    enterPercentile?: (ctx: PercentileContext) => void;
+    exitPercentile?: (ctx: PercentileContext) => void;
+    enterUnquotedIdentifier?: (ctx: UnquotedIdentifierContext) => void;
+    exitUnquotedIdentifier?: (ctx: UnquotedIdentifierContext) => void;
+    enterQuotedIdentifierAlternative?: (ctx: QuotedIdentifierAlternativeContext) => void;
+    exitQuotedIdentifierAlternative?: (ctx: QuotedIdentifierAlternativeContext) => void;
+    enterTableFileFormat?: (ctx: TableFileFormatContext) => void;
+    exitTableFileFormat?: (ctx: TableFileFormatContext) => void;
+    enterGenericFileFormat?: (ctx: GenericFileFormatContext) => void;
+    exitGenericFileFormat?: (ctx: GenericFileFormatContext) => void;
+    enterSampleByPercentile?: (ctx: SampleByPercentileContext) => void;
+    exitSampleByPercentile?: (ctx: SampleByPercentileContext) => void;
+    enterSampleByRows?: (ctx: SampleByRowsContext) => void;
+    exitSampleByRows?: (ctx: SampleByRowsContext) => void;
+    enterSampleByBucket?: (ctx: SampleByBucketContext) => void;
+    exitSampleByBucket?: (ctx: SampleByBucketContext) => void;
+    enterSampleByBytes?: (ctx: SampleByBytesContext) => void;
+    exitSampleByBytes?: (ctx: SampleByBytesContext) => void;
+    enterNullLiteral?: (ctx: NullLiteralContext) => void;
+    exitNullLiteral?: (ctx: NullLiteralContext) => void;
+    enterPosParameterLiteral?: (ctx: PosParameterLiteralContext) => void;
+    exitPosParameterLiteral?: (ctx: PosParameterLiteralContext) => void;
+    enterNamedParameterLiteral?: (ctx: NamedParameterLiteralContext) => void;
+    exitNamedParameterLiteral?: (ctx: NamedParameterLiteralContext) => void;
+    enterIntervalLiteral?: (ctx: IntervalLiteralContext) => void;
+    exitIntervalLiteral?: (ctx: IntervalLiteralContext) => void;
+    enterTypeConstructor?: (ctx: TypeConstructorContext) => void;
+    exitTypeConstructor?: (ctx: TypeConstructorContext) => void;
+    enterNumericLiteral?: (ctx: NumericLiteralContext) => void;
+    exitNumericLiteral?: (ctx: NumericLiteralContext) => void;
+    enterBooleanLiteral?: (ctx: BooleanLiteralContext) => void;
+    exitBooleanLiteral?: (ctx: BooleanLiteralContext) => void;
+    enterStringLiteral?: (ctx: StringLiteralContext) => void;
+    exitStringLiteral?: (ctx: StringLiteralContext) => void;
+    enterRowFormatSerde?: (ctx: RowFormatSerdeContext) => void;
+    exitRowFormatSerde?: (ctx: RowFormatSerdeContext) => void;
+    enterRowFormatDelimited?: (ctx: RowFormatDelimitedContext) => void;
+    exitRowFormatDelimited?: (ctx: RowFormatDelimitedContext) => void;
+    enterComplexDataType?: (ctx: ComplexDataTypeContext) => void;
+    exitComplexDataType?: (ctx: ComplexDataTypeContext) => void;
+    enterYearMonthIntervalDataType?: (ctx: YearMonthIntervalDataTypeContext) => void;
+    exitYearMonthIntervalDataType?: (ctx: YearMonthIntervalDataTypeContext) => void;
+    enterDayTimeIntervalDataType?: (ctx: DayTimeIntervalDataTypeContext) => void;
+    exitDayTimeIntervalDataType?: (ctx: DayTimeIntervalDataTypeContext) => void;
+    enterPrimitiveDataType?: (ctx: PrimitiveDataTypeContext) => void;
+    exitPrimitiveDataType?: (ctx: PrimitiveDataTypeContext) => void;
+    enterTransformQuerySpecification?: (ctx: TransformQuerySpecificationContext) => void;
+    exitTransformQuerySpecification?: (ctx: TransformQuerySpecificationContext) => void;
+    enterRegularQuerySpecification?: (ctx: RegularQuerySpecificationContext) => void;
+    exitRegularQuerySpecification?: (ctx: RegularQuerySpecificationContext) => void;
+    enterErrorIdent?: (ctx: ErrorIdentContext) => void;
+    exitErrorIdent?: (ctx: ErrorIdentContext) => void;
+    enterRealIdent?: (ctx: RealIdentContext) => void;
+    exitRealIdent?: (ctx: RealIdentContext) => void;
+    enterWindowRef?: (ctx: WindowRefContext) => void;
+    exitWindowRef?: (ctx: WindowRefContext) => void;
+    enterWindowDef?: (ctx: WindowDefContext) => void;
+    exitWindowDef?: (ctx: WindowDefContext) => void;
+    enterIdentityTransform?: (ctx: IdentityTransformContext) => void;
+    exitIdentityTransform?: (ctx: IdentityTransformContext) => void;
+    enterApplyTransform?: (ctx: ApplyTransformContext) => void;
+    exitApplyTransform?: (ctx: ApplyTransformContext) => void;
+    enterStatementDefault?: (ctx: StatementDefaultContext) => void;
+    exitStatementDefault?: (ctx: StatementDefaultContext) => void;
+    enterDmlStatement?: (ctx: DmlStatementContext) => void;
+    exitDmlStatement?: (ctx: DmlStatementContext) => void;
+    enterUse?: (ctx: UseContext) => void;
+    exitUse?: (ctx: UseContext) => void;
+    enterUseNamespace?: (ctx: UseNamespaceContext) => void;
+    exitUseNamespace?: (ctx: UseNamespaceContext) => void;
+    enterSetCatalog?: (ctx: SetCatalogContext) => void;
+    exitSetCatalog?: (ctx: SetCatalogContext) => void;
+    enterCreateNamespace?: (ctx: CreateNamespaceContext) => void;
+    exitCreateNamespace?: (ctx: CreateNamespaceContext) => void;
+    enterSetNamespaceProperties?: (ctx: SetNamespacePropertiesContext) => void;
+    exitSetNamespaceProperties?: (ctx: SetNamespacePropertiesContext) => void;
+    enterSetNamespaceLocation?: (ctx: SetNamespaceLocationContext) => void;
+    exitSetNamespaceLocation?: (ctx: SetNamespaceLocationContext) => void;
+    enterDropNamespace?: (ctx: DropNamespaceContext) => void;
+    exitDropNamespace?: (ctx: DropNamespaceContext) => void;
+    enterShowNamespaces?: (ctx: ShowNamespacesContext) => void;
+    exitShowNamespaces?: (ctx: ShowNamespacesContext) => void;
+    enterCreateTable?: (ctx: CreateTableContext) => void;
+    exitCreateTable?: (ctx: CreateTableContext) => void;
+    enterCreateTableLike?: (ctx: CreateTableLikeContext) => void;
+    exitCreateTableLike?: (ctx: CreateTableLikeContext) => void;
+    enterReplaceTable?: (ctx: ReplaceTableContext) => void;
+    exitReplaceTable?: (ctx: ReplaceTableContext) => void;
+    enterAnalyze?: (ctx: AnalyzeContext) => void;
+    exitAnalyze?: (ctx: AnalyzeContext) => void;
+    enterAnalyzeTables?: (ctx: AnalyzeTablesContext) => void;
+    exitAnalyzeTables?: (ctx: AnalyzeTablesContext) => void;
+    enterAddTableColumns?: (ctx: AddTableColumnsContext) => void;
+    exitAddTableColumns?: (ctx: AddTableColumnsContext) => void;
+    enterRenameTableColumn?: (ctx: RenameTableColumnContext) => void;
+    exitRenameTableColumn?: (ctx: RenameTableColumnContext) => void;
+    enterDropTableColumns?: (ctx: DropTableColumnsContext) => void;
+    exitDropTableColumns?: (ctx: DropTableColumnsContext) => void;
+    enterRenameTable?: (ctx: RenameTableContext) => void;
+    exitRenameTable?: (ctx: RenameTableContext) => void;
+    enterSetTableProperties?: (ctx: SetTablePropertiesContext) => void;
+    exitSetTableProperties?: (ctx: SetTablePropertiesContext) => void;
+    enterUnsetTableProperties?: (ctx: UnsetTablePropertiesContext) => void;
+    exitUnsetTableProperties?: (ctx: UnsetTablePropertiesContext) => void;
+    enterAlterTableAlterColumn?: (ctx: AlterTableAlterColumnContext) => void;
+    exitAlterTableAlterColumn?: (ctx: AlterTableAlterColumnContext) => void;
+    enterHiveChangeColumn?: (ctx: HiveChangeColumnContext) => void;
+    exitHiveChangeColumn?: (ctx: HiveChangeColumnContext) => void;
+    enterHiveReplaceColumns?: (ctx: HiveReplaceColumnsContext) => void;
+    exitHiveReplaceColumns?: (ctx: HiveReplaceColumnsContext) => void;
+    enterSetTableSerDe?: (ctx: SetTableSerDeContext) => void;
+    exitSetTableSerDe?: (ctx: SetTableSerDeContext) => void;
+    enterAddTablePartition?: (ctx: AddTablePartitionContext) => void;
+    exitAddTablePartition?: (ctx: AddTablePartitionContext) => void;
+    enterRenameTablePartition?: (ctx: RenameTablePartitionContext) => void;
+    exitRenameTablePartition?: (ctx: RenameTablePartitionContext) => void;
+    enterDropTablePartitions?: (ctx: DropTablePartitionsContext) => void;
+    exitDropTablePartitions?: (ctx: DropTablePartitionsContext) => void;
+    enterSetTableLocation?: (ctx: SetTableLocationContext) => void;
+    exitSetTableLocation?: (ctx: SetTableLocationContext) => void;
+    enterRecoverPartitions?: (ctx: RecoverPartitionsContext) => void;
+    exitRecoverPartitions?: (ctx: RecoverPartitionsContext) => void;
+    enterDropTable?: (ctx: DropTableContext) => void;
+    exitDropTable?: (ctx: DropTableContext) => void;
+    enterDropView?: (ctx: DropViewContext) => void;
+    exitDropView?: (ctx: DropViewContext) => void;
+    enterCreateView?: (ctx: CreateViewContext) => void;
+    exitCreateView?: (ctx: CreateViewContext) => void;
+    enterCreateTempViewUsing?: (ctx: CreateTempViewUsingContext) => void;
+    exitCreateTempViewUsing?: (ctx: CreateTempViewUsingContext) => void;
+    enterAlterViewQuery?: (ctx: AlterViewQueryContext) => void;
+    exitAlterViewQuery?: (ctx: AlterViewQueryContext) => void;
+    enterCreateFunction?: (ctx: CreateFunctionContext) => void;
+    exitCreateFunction?: (ctx: CreateFunctionContext) => void;
+    enterDropFunction?: (ctx: DropFunctionContext) => void;
+    exitDropFunction?: (ctx: DropFunctionContext) => void;
+    enterExplain?: (ctx: ExplainContext) => void;
+    exitExplain?: (ctx: ExplainContext) => void;
+    enterShowTables?: (ctx: ShowTablesContext) => void;
+    exitShowTables?: (ctx: ShowTablesContext) => void;
+    enterShowTableExtended?: (ctx: ShowTableExtendedContext) => void;
+    exitShowTableExtended?: (ctx: ShowTableExtendedContext) => void;
+    enterShowTblProperties?: (ctx: ShowTblPropertiesContext) => void;
+    exitShowTblProperties?: (ctx: ShowTblPropertiesContext) => void;
+    enterShowColumns?: (ctx: ShowColumnsContext) => void;
+    exitShowColumns?: (ctx: ShowColumnsContext) => void;
+    enterShowViews?: (ctx: ShowViewsContext) => void;
+    exitShowViews?: (ctx: ShowViewsContext) => void;
+    enterShowPartitions?: (ctx: ShowPartitionsContext) => void;
+    exitShowPartitions?: (ctx: ShowPartitionsContext) => void;
+    enterShowFunctions?: (ctx: ShowFunctionsContext) => void;
+    exitShowFunctions?: (ctx: ShowFunctionsContext) => void;
+    enterShowCreateTable?: (ctx: ShowCreateTableContext) => void;
+    exitShowCreateTable?: (ctx: ShowCreateTableContext) => void;
+    enterShowCurrentNamespace?: (ctx: ShowCurrentNamespaceContext) => void;
+    exitShowCurrentNamespace?: (ctx: ShowCurrentNamespaceContext) => void;
+    enterShowCatalogs?: (ctx: ShowCatalogsContext) => void;
+    exitShowCatalogs?: (ctx: ShowCatalogsContext) => void;
+    enterDescribeFunction?: (ctx: DescribeFunctionContext) => void;
+    exitDescribeFunction?: (ctx: DescribeFunctionContext) => void;
+    enterDescribeNamespace?: (ctx: DescribeNamespaceContext) => void;
+    exitDescribeNamespace?: (ctx: DescribeNamespaceContext) => void;
+    enterDescribeRelation?: (ctx: DescribeRelationContext) => void;
+    exitDescribeRelation?: (ctx: DescribeRelationContext) => void;
+    enterDescribeQuery?: (ctx: DescribeQueryContext) => void;
+    exitDescribeQuery?: (ctx: DescribeQueryContext) => void;
+    enterCommentNamespace?: (ctx: CommentNamespaceContext) => void;
+    exitCommentNamespace?: (ctx: CommentNamespaceContext) => void;
+    enterCommentTable?: (ctx: CommentTableContext) => void;
+    exitCommentTable?: (ctx: CommentTableContext) => void;
+    enterRefreshTable?: (ctx: RefreshTableContext) => void;
+    exitRefreshTable?: (ctx: RefreshTableContext) => void;
+    enterRefreshFunction?: (ctx: RefreshFunctionContext) => void;
+    exitRefreshFunction?: (ctx: RefreshFunctionContext) => void;
+    enterRefreshResource?: (ctx: RefreshResourceContext) => void;
+    exitRefreshResource?: (ctx: RefreshResourceContext) => void;
+    enterCacheTable?: (ctx: CacheTableContext) => void;
+    exitCacheTable?: (ctx: CacheTableContext) => void;
+    enterUncacheTable?: (ctx: UncacheTableContext) => void;
+    exitUncacheTable?: (ctx: UncacheTableContext) => void;
+    enterClearCache?: (ctx: ClearCacheContext) => void;
+    exitClearCache?: (ctx: ClearCacheContext) => void;
+    enterLoadData?: (ctx: LoadDataContext) => void;
+    exitLoadData?: (ctx: LoadDataContext) => void;
+    enterTruncateTable?: (ctx: TruncateTableContext) => void;
+    exitTruncateTable?: (ctx: TruncateTableContext) => void;
+    enterRepairTable?: (ctx: RepairTableContext) => void;
+    exitRepairTable?: (ctx: RepairTableContext) => void;
+    enterManageResource?: (ctx: ManageResourceContext) => void;
+    exitManageResource?: (ctx: ManageResourceContext) => void;
+    enterFailNativeCommand?: (ctx: FailNativeCommandContext) => void;
+    exitFailNativeCommand?: (ctx: FailNativeCommandContext) => void;
+    enterSetTimeZone?: (ctx: SetTimeZoneContext) => void;
+    exitSetTimeZone?: (ctx: SetTimeZoneContext) => void;
+    enterSetQuotedConfiguration?: (ctx: SetQuotedConfigurationContext) => void;
+    exitSetQuotedConfiguration?: (ctx: SetQuotedConfigurationContext) => void;
+    enterSetConfiguration?: (ctx: SetConfigurationContext) => void;
+    exitSetConfiguration?: (ctx: SetConfigurationContext) => void;
+    enterResetQuotedConfiguration?: (ctx: ResetQuotedConfigurationContext) => void;
+    exitResetQuotedConfiguration?: (ctx: ResetQuotedConfigurationContext) => void;
+    enterResetConfiguration?: (ctx: ResetConfigurationContext) => void;
+    exitResetConfiguration?: (ctx: ResetConfigurationContext) => void;
+    enterCreateIndex?: (ctx: CreateIndexContext) => void;
+    exitCreateIndex?: (ctx: CreateIndexContext) => void;
+    enterDropIndex?: (ctx: DropIndexContext) => void;
+    exitDropIndex?: (ctx: DropIndexContext) => void;
+    enterLogicalNot?: (ctx: LogicalNotContext) => void;
+    exitLogicalNot?: (ctx: LogicalNotContext) => void;
+    enterExists?: (ctx: ExistsContext) => void;
+    exitExists?: (ctx: ExistsContext) => void;
+    enterPredicated?: (ctx: PredicatedContext) => void;
+    exitPredicated?: (ctx: PredicatedContext) => void;
+    enterLogicalBinary?: (ctx: LogicalBinaryContext) => void;
+    exitLogicalBinary?: (ctx: LogicalBinaryContext) => void;
+    enterProgram?: (ctx: ProgramContext) => void;
+    exitProgram?: (ctx: ProgramContext) => void;
+    enterStatements?: (ctx: StatementsContext) => void;
+    exitStatements?: (ctx: StatementsContext) => void;
+    enterStatementEnd?: (ctx: StatementEndContext) => void;
+    exitStatementEnd?: (ctx: StatementEndContext) => void;
+    enterSingleStatement?: (ctx: SingleStatementContext) => void;
+    exitSingleStatement?: (ctx: SingleStatementContext) => void;
+    enterSingleExpression?: (ctx: SingleExpressionContext) => void;
+    exitSingleExpression?: (ctx: SingleExpressionContext) => void;
+    enterSingleTableIdentifier?: (ctx: SingleTableIdentifierContext) => void;
+    exitSingleTableIdentifier?: (ctx: SingleTableIdentifierContext) => void;
+    enterSingleMultipartIdentifier?: (ctx: SingleMultipartIdentifierContext) => void;
+    exitSingleMultipartIdentifier?: (ctx: SingleMultipartIdentifierContext) => void;
+    enterSingleFunctionIdentifier?: (ctx: SingleFunctionIdentifierContext) => void;
+    exitSingleFunctionIdentifier?: (ctx: SingleFunctionIdentifierContext) => void;
+    enterSingleDataType?: (ctx: SingleDataTypeContext) => void;
+    exitSingleDataType?: (ctx: SingleDataTypeContext) => void;
+    enterSingleTableSchema?: (ctx: SingleTableSchemaContext) => void;
+    exitSingleTableSchema?: (ctx: SingleTableSchemaContext) => void;
+    enterStatementForFolding?: (ctx: StatementForFoldingContext) => void;
+    exitStatementForFolding?: (ctx: StatementForFoldingContext) => void;
+    enterStatement?: (ctx: StatementContext) => void;
+    exitStatement?: (ctx: StatementContext) => void;
+    enterTimezone?: (ctx: TimezoneContext) => void;
+    exitTimezone?: (ctx: TimezoneContext) => void;
+    enterConfigKey?: (ctx: ConfigKeyContext) => void;
+    exitConfigKey?: (ctx: ConfigKeyContext) => void;
+    enterConfigValue?: (ctx: ConfigValueContext) => void;
+    exitConfigValue?: (ctx: ConfigValueContext) => void;
+    enterUnsupportedHiveNativeCommands?: (ctx: UnsupportedHiveNativeCommandsContext) => void;
+    exitUnsupportedHiveNativeCommands?: (ctx: UnsupportedHiveNativeCommandsContext) => void;
+    enterCreateTableHeader?: (ctx: CreateTableHeaderContext) => void;
+    exitCreateTableHeader?: (ctx: CreateTableHeaderContext) => void;
+    enterReplaceTableHeader?: (ctx: ReplaceTableHeaderContext) => void;
+    exitReplaceTableHeader?: (ctx: ReplaceTableHeaderContext) => void;
+    enterBucketSpec?: (ctx: BucketSpecContext) => void;
+    exitBucketSpec?: (ctx: BucketSpecContext) => void;
+    enterSkewSpec?: (ctx: SkewSpecContext) => void;
+    exitSkewSpec?: (ctx: SkewSpecContext) => void;
+    enterLocationSpec?: (ctx: LocationSpecContext) => void;
+    exitLocationSpec?: (ctx: LocationSpecContext) => void;
+    enterCommentSpec?: (ctx: CommentSpecContext) => void;
+    exitCommentSpec?: (ctx: CommentSpecContext) => void;
+    enterQuery?: (ctx: QueryContext) => void;
+    exitQuery?: (ctx: QueryContext) => void;
+    enterInsertInto?: (ctx: InsertIntoContext) => void;
+    exitInsertInto?: (ctx: InsertIntoContext) => void;
+    enterPartitionSpecLocation?: (ctx: PartitionSpecLocationContext) => void;
+    exitPartitionSpecLocation?: (ctx: PartitionSpecLocationContext) => void;
+    enterPartitionSpec?: (ctx: PartitionSpecContext) => void;
+    exitPartitionSpec?: (ctx: PartitionSpecContext) => void;
+    enterPartitionVal?: (ctx: PartitionValContext) => void;
+    exitPartitionVal?: (ctx: PartitionValContext) => void;
+    enterNamespace?: (ctx: NamespaceContext) => void;
+    exitNamespace?: (ctx: NamespaceContext) => void;
+    enterNamespaces?: (ctx: NamespacesContext) => void;
+    exitNamespaces?: (ctx: NamespacesContext) => void;
+    enterDescribeFuncName?: (ctx: DescribeFuncNameContext) => void;
+    exitDescribeFuncName?: (ctx: DescribeFuncNameContext) => void;
+    enterDescribeColName?: (ctx: DescribeColNameContext) => void;
+    exitDescribeColName?: (ctx: DescribeColNameContext) => void;
+    enterCtes?: (ctx: CtesContext) => void;
+    exitCtes?: (ctx: CtesContext) => void;
+    enterNamedQuery?: (ctx: NamedQueryContext) => void;
+    exitNamedQuery?: (ctx: NamedQueryContext) => void;
+    enterTableProvider?: (ctx: TableProviderContext) => void;
+    exitTableProvider?: (ctx: TableProviderContext) => void;
+    enterCreateTableClauses?: (ctx: CreateTableClausesContext) => void;
+    exitCreateTableClauses?: (ctx: CreateTableClausesContext) => void;
+    enterPropertyList?: (ctx: PropertyListContext) => void;
+    exitPropertyList?: (ctx: PropertyListContext) => void;
+    enterProperty?: (ctx: PropertyContext) => void;
+    exitProperty?: (ctx: PropertyContext) => void;
+    enterPropertyKey?: (ctx: PropertyKeyContext) => void;
+    exitPropertyKey?: (ctx: PropertyKeyContext) => void;
+    enterPropertyValue?: (ctx: PropertyValueContext) => void;
+    exitPropertyValue?: (ctx: PropertyValueContext) => void;
+    enterExpressionPropertyList?: (ctx: ExpressionPropertyListContext) => void;
+    exitExpressionPropertyList?: (ctx: ExpressionPropertyListContext) => void;
+    enterExpressionProperty?: (ctx: ExpressionPropertyContext) => void;
+    exitExpressionProperty?: (ctx: ExpressionPropertyContext) => void;
+    enterConstantList?: (ctx: ConstantListContext) => void;
+    exitConstantList?: (ctx: ConstantListContext) => void;
+    enterNestedConstantList?: (ctx: NestedConstantListContext) => void;
+    exitNestedConstantList?: (ctx: NestedConstantListContext) => void;
+    enterCreateFileFormat?: (ctx: CreateFileFormatContext) => void;
+    exitCreateFileFormat?: (ctx: CreateFileFormatContext) => void;
+    enterFileFormat?: (ctx: FileFormatContext) => void;
+    exitFileFormat?: (ctx: FileFormatContext) => void;
+    enterStorageHandler?: (ctx: StorageHandlerContext) => void;
+    exitStorageHandler?: (ctx: StorageHandlerContext) => void;
+    enterResource?: (ctx: ResourceContext) => void;
+    exitResource?: (ctx: ResourceContext) => void;
+    enterDmlStatementNoWith?: (ctx: DmlStatementNoWithContext) => void;
+    exitDmlStatementNoWith?: (ctx: DmlStatementNoWithContext) => void;
+    enterIdentifierReference?: (ctx: IdentifierReferenceContext) => void;
+    exitIdentifierReference?: (ctx: IdentifierReferenceContext) => void;
+    enterQueryOrganization?: (ctx: QueryOrganizationContext) => void;
+    exitQueryOrganization?: (ctx: QueryOrganizationContext) => void;
+    enterMultiInsertQueryBody?: (ctx: MultiInsertQueryBodyContext) => void;
+    exitMultiInsertQueryBody?: (ctx: MultiInsertQueryBodyContext) => void;
+    enterQueryTerm?: (ctx: QueryTermContext) => void;
+    exitQueryTerm?: (ctx: QueryTermContext) => void;
+    enterQueryPrimary?: (ctx: QueryPrimaryContext) => void;
+    exitQueryPrimary?: (ctx: QueryPrimaryContext) => void;
+    enterSortItem?: (ctx: SortItemContext) => void;
+    exitSortItem?: (ctx: SortItemContext) => void;
+    enterFromStatement?: (ctx: FromStatementContext) => void;
+    exitFromStatement?: (ctx: FromStatementContext) => void;
+    enterFromStatementBody?: (ctx: FromStatementBodyContext) => void;
+    exitFromStatementBody?: (ctx: FromStatementBodyContext) => void;
+    enterQuerySpecification?: (ctx: QuerySpecificationContext) => void;
+    exitQuerySpecification?: (ctx: QuerySpecificationContext) => void;
+    enterTransformClause?: (ctx: TransformClauseContext) => void;
+    exitTransformClause?: (ctx: TransformClauseContext) => void;
+    enterSelectClause?: (ctx: SelectClauseContext) => void;
+    exitSelectClause?: (ctx: SelectClauseContext) => void;
+    enterSetClause?: (ctx: SetClauseContext) => void;
+    exitSetClause?: (ctx: SetClauseContext) => void;
+    enterMatchedClause?: (ctx: MatchedClauseContext) => void;
+    exitMatchedClause?: (ctx: MatchedClauseContext) => void;
+    enterNotMatchedClause?: (ctx: NotMatchedClauseContext) => void;
+    exitNotMatchedClause?: (ctx: NotMatchedClauseContext) => void;
+    enterNotMatchedBySourceClause?: (ctx: NotMatchedBySourceClauseContext) => void;
+    exitNotMatchedBySourceClause?: (ctx: NotMatchedBySourceClauseContext) => void;
+    enterMatchedAction?: (ctx: MatchedActionContext) => void;
+    exitMatchedAction?: (ctx: MatchedActionContext) => void;
+    enterNotMatchedAction?: (ctx: NotMatchedActionContext) => void;
+    exitNotMatchedAction?: (ctx: NotMatchedActionContext) => void;
+    enterNotMatchedBySourceAction?: (ctx: NotMatchedBySourceActionContext) => void;
+    exitNotMatchedBySourceAction?: (ctx: NotMatchedBySourceActionContext) => void;
+    enterAssignmentList?: (ctx: AssignmentListContext) => void;
+    exitAssignmentList?: (ctx: AssignmentListContext) => void;
+    enterAssignment?: (ctx: AssignmentContext) => void;
+    exitAssignment?: (ctx: AssignmentContext) => void;
+    enterWhereClause?: (ctx: WhereClauseContext) => void;
+    exitWhereClause?: (ctx: WhereClauseContext) => void;
+    enterHavingClause?: (ctx: HavingClauseContext) => void;
+    exitHavingClause?: (ctx: HavingClauseContext) => void;
+    enterHint?: (ctx: HintContext) => void;
+    exitHint?: (ctx: HintContext) => void;
+    enterHintStatement?: (ctx: HintStatementContext) => void;
+    exitHintStatement?: (ctx: HintStatementContext) => void;
+    enterFromClause?: (ctx: FromClauseContext) => void;
+    exitFromClause?: (ctx: FromClauseContext) => void;
+    enterTemporalClause?: (ctx: TemporalClauseContext) => void;
+    exitTemporalClause?: (ctx: TemporalClauseContext) => void;
+    enterAggregationClause?: (ctx: AggregationClauseContext) => void;
+    exitAggregationClause?: (ctx: AggregationClauseContext) => void;
+    enterGroupByClause?: (ctx: GroupByClauseContext) => void;
+    exitGroupByClause?: (ctx: GroupByClauseContext) => void;
+    enterGroupingAnalytics?: (ctx: GroupingAnalyticsContext) => void;
+    exitGroupingAnalytics?: (ctx: GroupingAnalyticsContext) => void;
+    enterGroupingElement?: (ctx: GroupingElementContext) => void;
+    exitGroupingElement?: (ctx: GroupingElementContext) => void;
+    enterGroupingSet?: (ctx: GroupingSetContext) => void;
+    exitGroupingSet?: (ctx: GroupingSetContext) => void;
+    enterPivotClause?: (ctx: PivotClauseContext) => void;
+    exitPivotClause?: (ctx: PivotClauseContext) => void;
+    enterPivotColumn?: (ctx: PivotColumnContext) => void;
+    exitPivotColumn?: (ctx: PivotColumnContext) => void;
+    enterPivotValue?: (ctx: PivotValueContext) => void;
+    exitPivotValue?: (ctx: PivotValueContext) => void;
+    enterUnpivotClause?: (ctx: UnpivotClauseContext) => void;
+    exitUnpivotClause?: (ctx: UnpivotClauseContext) => void;
+    enterUnpivotNullClause?: (ctx: UnpivotNullClauseContext) => void;
+    exitUnpivotNullClause?: (ctx: UnpivotNullClauseContext) => void;
+    enterUnpivotOperator?: (ctx: UnpivotOperatorContext) => void;
+    exitUnpivotOperator?: (ctx: UnpivotOperatorContext) => void;
+    enterUnpivotSingleValueColumnClause?: (ctx: UnpivotSingleValueColumnClauseContext) => void;
+    exitUnpivotSingleValueColumnClause?: (ctx: UnpivotSingleValueColumnClauseContext) => void;
+    enterUnpivotMultiValueColumnClause?: (ctx: UnpivotMultiValueColumnClauseContext) => void;
+    exitUnpivotMultiValueColumnClause?: (ctx: UnpivotMultiValueColumnClauseContext) => void;
+    enterUnpivotColumnSet?: (ctx: UnpivotColumnSetContext) => void;
+    exitUnpivotColumnSet?: (ctx: UnpivotColumnSetContext) => void;
+    enterUnpivotValueColumn?: (ctx: UnpivotValueColumnContext) => void;
+    exitUnpivotValueColumn?: (ctx: UnpivotValueColumnContext) => void;
+    enterUnpivotNameColumn?: (ctx: UnpivotNameColumnContext) => void;
+    exitUnpivotNameColumn?: (ctx: UnpivotNameColumnContext) => void;
+    enterUnpivotColumnAndAlias?: (ctx: UnpivotColumnAndAliasContext) => void;
+    exitUnpivotColumnAndAlias?: (ctx: UnpivotColumnAndAliasContext) => void;
+    enterUnpivotColumn?: (ctx: UnpivotColumnContext) => void;
+    exitUnpivotColumn?: (ctx: UnpivotColumnContext) => void;
+    enterUnpivotAlias?: (ctx: UnpivotAliasContext) => void;
+    exitUnpivotAlias?: (ctx: UnpivotAliasContext) => void;
+    enterLateralView?: (ctx: LateralViewContext) => void;
+    exitLateralView?: (ctx: LateralViewContext) => void;
+    enterSetQuantifier?: (ctx: SetQuantifierContext) => void;
+    exitSetQuantifier?: (ctx: SetQuantifierContext) => void;
+    enterRelation?: (ctx: RelationContext) => void;
+    exitRelation?: (ctx: RelationContext) => void;
+    enterRelationExtension?: (ctx: RelationExtensionContext) => void;
+    exitRelationExtension?: (ctx: RelationExtensionContext) => void;
+    enterJoinRelation?: (ctx: JoinRelationContext) => void;
+    exitJoinRelation?: (ctx: JoinRelationContext) => void;
+    enterJoinType?: (ctx: JoinTypeContext) => void;
+    exitJoinType?: (ctx: JoinTypeContext) => void;
+    enterJoinCriteria?: (ctx: JoinCriteriaContext) => void;
+    exitJoinCriteria?: (ctx: JoinCriteriaContext) => void;
+    enterSample?: (ctx: SampleContext) => void;
+    exitSample?: (ctx: SampleContext) => void;
+    enterSampleMethod?: (ctx: SampleMethodContext) => void;
+    exitSampleMethod?: (ctx: SampleMethodContext) => void;
+    enterIdentifierList?: (ctx: IdentifierListContext) => void;
+    exitIdentifierList?: (ctx: IdentifierListContext) => void;
+    enterIdentifierSeq?: (ctx: IdentifierSeqContext) => void;
+    exitIdentifierSeq?: (ctx: IdentifierSeqContext) => void;
+    enterOrderedIdentifierList?: (ctx: OrderedIdentifierListContext) => void;
+    exitOrderedIdentifierList?: (ctx: OrderedIdentifierListContext) => void;
+    enterOrderedIdentifier?: (ctx: OrderedIdentifierContext) => void;
+    exitOrderedIdentifier?: (ctx: OrderedIdentifierContext) => void;
+    enterIdentifierCommentList?: (ctx: IdentifierCommentListContext) => void;
+    exitIdentifierCommentList?: (ctx: IdentifierCommentListContext) => void;
+    enterIdentifierComment?: (ctx: IdentifierCommentContext) => void;
+    exitIdentifierComment?: (ctx: IdentifierCommentContext) => void;
+    enterRelationPrimary?: (ctx: RelationPrimaryContext) => void;
+    exitRelationPrimary?: (ctx: RelationPrimaryContext) => void;
+    enterInlineTable?: (ctx: InlineTableContext) => void;
+    exitInlineTable?: (ctx: InlineTableContext) => void;
+    enterFunctionTableSubqueryArgument?: (ctx: FunctionTableSubqueryArgumentContext) => void;
+    exitFunctionTableSubqueryArgument?: (ctx: FunctionTableSubqueryArgumentContext) => void;
+    enterTableArgumentPartitioning?: (ctx: TableArgumentPartitioningContext) => void;
+    exitTableArgumentPartitioning?: (ctx: TableArgumentPartitioningContext) => void;
+    enterFunctionTableNamedArgumentExpression?: (ctx: FunctionTableNamedArgumentExpressionContext) => void;
+    exitFunctionTableNamedArgumentExpression?: (ctx: FunctionTableNamedArgumentExpressionContext) => void;
+    enterFunctionTableReferenceArgument?: (ctx: FunctionTableReferenceArgumentContext) => void;
+    exitFunctionTableReferenceArgument?: (ctx: FunctionTableReferenceArgumentContext) => void;
+    enterFunctionTableArgument?: (ctx: FunctionTableArgumentContext) => void;
+    exitFunctionTableArgument?: (ctx: FunctionTableArgumentContext) => void;
+    enterFunctionTable?: (ctx: FunctionTableContext) => void;
+    exitFunctionTable?: (ctx: FunctionTableContext) => void;
+    enterTableAlias?: (ctx: TableAliasContext) => void;
+    exitTableAlias?: (ctx: TableAliasContext) => void;
+    enterRowFormat?: (ctx: RowFormatContext) => void;
+    exitRowFormat?: (ctx: RowFormatContext) => void;
+    enterMultipartIdentifierList?: (ctx: MultipartIdentifierListContext) => void;
+    exitMultipartIdentifierList?: (ctx: MultipartIdentifierListContext) => void;
+    enterMultipartIdentifier?: (ctx: MultipartIdentifierContext) => void;
+    exitMultipartIdentifier?: (ctx: MultipartIdentifierContext) => void;
+    enterMultipartIdentifierPropertyList?: (ctx: MultipartIdentifierPropertyListContext) => void;
+    exitMultipartIdentifierPropertyList?: (ctx: MultipartIdentifierPropertyListContext) => void;
+    enterMultipartIdentifierProperty?: (ctx: MultipartIdentifierPropertyContext) => void;
+    exitMultipartIdentifierProperty?: (ctx: MultipartIdentifierPropertyContext) => void;
+    enterTableIdentifier?: (ctx: TableIdentifierContext) => void;
+    exitTableIdentifier?: (ctx: TableIdentifierContext) => void;
+    enterFunctionIdentifier?: (ctx: FunctionIdentifierContext) => void;
+    exitFunctionIdentifier?: (ctx: FunctionIdentifierContext) => void;
+    enterNamedExpression?: (ctx: NamedExpressionContext) => void;
+    exitNamedExpression?: (ctx: NamedExpressionContext) => void;
+    enterNamedExpressionSeq?: (ctx: NamedExpressionSeqContext) => void;
+    exitNamedExpressionSeq?: (ctx: NamedExpressionSeqContext) => void;
+    enterPartitionFieldList?: (ctx: PartitionFieldListContext) => void;
+    exitPartitionFieldList?: (ctx: PartitionFieldListContext) => void;
+    enterPartitionField?: (ctx: PartitionFieldContext) => void;
+    exitPartitionField?: (ctx: PartitionFieldContext) => void;
+    enterTransform?: (ctx: TransformContext) => void;
+    exitTransform?: (ctx: TransformContext) => void;
+    enterTransformArgument?: (ctx: TransformArgumentContext) => void;
+    exitTransformArgument?: (ctx: TransformArgumentContext) => void;
+    enterExpression?: (ctx: ExpressionContext) => void;
+    exitExpression?: (ctx: ExpressionContext) => void;
+    enterNamedArgumentExpression?: (ctx: NamedArgumentExpressionContext) => void;
+    exitNamedArgumentExpression?: (ctx: NamedArgumentExpressionContext) => void;
+    enterFunctionArgument?: (ctx: FunctionArgumentContext) => void;
+    exitFunctionArgument?: (ctx: FunctionArgumentContext) => void;
+    enterExpressionSeq?: (ctx: ExpressionSeqContext) => void;
+    exitExpressionSeq?: (ctx: ExpressionSeqContext) => void;
+    enterBooleanExpression?: (ctx: BooleanExpressionContext) => void;
+    exitBooleanExpression?: (ctx: BooleanExpressionContext) => void;
+    enterPredicate?: (ctx: PredicateContext) => void;
+    exitPredicate?: (ctx: PredicateContext) => void;
+    enterValueExpression?: (ctx: ValueExpressionContext) => void;
+    exitValueExpression?: (ctx: ValueExpressionContext) => void;
+    enterDatetimeUnit?: (ctx: DatetimeUnitContext) => void;
+    exitDatetimeUnit?: (ctx: DatetimeUnitContext) => void;
+    enterPrimaryExpression?: (ctx: PrimaryExpressionContext) => void;
+    exitPrimaryExpression?: (ctx: PrimaryExpressionContext) => void;
+    enterLiteralType?: (ctx: LiteralTypeContext) => void;
+    exitLiteralType?: (ctx: LiteralTypeContext) => void;
+    enterConstant?: (ctx: ConstantContext) => void;
+    exitConstant?: (ctx: ConstantContext) => void;
+    enterComparisonOperator?: (ctx: ComparisonOperatorContext) => void;
+    exitComparisonOperator?: (ctx: ComparisonOperatorContext) => void;
+    enterArithmeticOperator?: (ctx: ArithmeticOperatorContext) => void;
+    exitArithmeticOperator?: (ctx: ArithmeticOperatorContext) => void;
+    enterPredicateOperator?: (ctx: PredicateOperatorContext) => void;
+    exitPredicateOperator?: (ctx: PredicateOperatorContext) => void;
+    enterBooleanValue?: (ctx: BooleanValueContext) => void;
+    exitBooleanValue?: (ctx: BooleanValueContext) => void;
+    enterInterval?: (ctx: IntervalContext) => void;
+    exitInterval?: (ctx: IntervalContext) => void;
+    enterErrorCapturingMultiUnitsInterval?: (ctx: ErrorCapturingMultiUnitsIntervalContext) => void;
+    exitErrorCapturingMultiUnitsInterval?: (ctx: ErrorCapturingMultiUnitsIntervalContext) => void;
+    enterMultiUnitsInterval?: (ctx: MultiUnitsIntervalContext) => void;
+    exitMultiUnitsInterval?: (ctx: MultiUnitsIntervalContext) => void;
+    enterErrorCapturingUnitToUnitInterval?: (ctx: ErrorCapturingUnitToUnitIntervalContext) => void;
+    exitErrorCapturingUnitToUnitInterval?: (ctx: ErrorCapturingUnitToUnitIntervalContext) => void;
+    enterUnitToUnitInterval?: (ctx: UnitToUnitIntervalContext) => void;
+    exitUnitToUnitInterval?: (ctx: UnitToUnitIntervalContext) => void;
+    enterIntervalValue?: (ctx: IntervalValueContext) => void;
+    exitIntervalValue?: (ctx: IntervalValueContext) => void;
+    enterUnitInMultiUnits?: (ctx: UnitInMultiUnitsContext) => void;
+    exitUnitInMultiUnits?: (ctx: UnitInMultiUnitsContext) => void;
+    enterUnitInUnitToUnit?: (ctx: UnitInUnitToUnitContext) => void;
+    exitUnitInUnitToUnit?: (ctx: UnitInUnitToUnitContext) => void;
+    enterColPosition?: (ctx: ColPositionContext) => void;
+    exitColPosition?: (ctx: ColPositionContext) => void;
+    enterType?: (ctx: TypeContext) => void;
+    exitType?: (ctx: TypeContext) => void;
+    enterDataType?: (ctx: DataTypeContext) => void;
+    exitDataType?: (ctx: DataTypeContext) => void;
+    enterQualifiedColTypeWithPositionList?: (ctx: QualifiedColTypeWithPositionListContext) => void;
+    exitQualifiedColTypeWithPositionList?: (ctx: QualifiedColTypeWithPositionListContext) => void;
+    enterQualifiedColTypeWithPosition?: (ctx: QualifiedColTypeWithPositionContext) => void;
+    exitQualifiedColTypeWithPosition?: (ctx: QualifiedColTypeWithPositionContext) => void;
+    enterColDefinitionDescriptorWithPosition?: (ctx: ColDefinitionDescriptorWithPositionContext) => void;
+    exitColDefinitionDescriptorWithPosition?: (ctx: ColDefinitionDescriptorWithPositionContext) => void;
+    enterDefaultExpression?: (ctx: DefaultExpressionContext) => void;
+    exitDefaultExpression?: (ctx: DefaultExpressionContext) => void;
+    enterColTypeList?: (ctx: ColTypeListContext) => void;
+    exitColTypeList?: (ctx: ColTypeListContext) => void;
+    enterColType?: (ctx: ColTypeContext) => void;
+    exitColType?: (ctx: ColTypeContext) => void;
+    enterCreateOrReplaceTableColTypeList?: (ctx: CreateOrReplaceTableColTypeListContext) => void;
+    exitCreateOrReplaceTableColTypeList?: (ctx: CreateOrReplaceTableColTypeListContext) => void;
+    enterCreateOrReplaceTableColType?: (ctx: CreateOrReplaceTableColTypeContext) => void;
+    exitCreateOrReplaceTableColType?: (ctx: CreateOrReplaceTableColTypeContext) => void;
+    enterColDefinitionOption?: (ctx: ColDefinitionOptionContext) => void;
+    exitColDefinitionOption?: (ctx: ColDefinitionOptionContext) => void;
+    enterGenerationExpression?: (ctx: GenerationExpressionContext) => void;
+    exitGenerationExpression?: (ctx: GenerationExpressionContext) => void;
+    enterComplexColTypeList?: (ctx: ComplexColTypeListContext) => void;
+    exitComplexColTypeList?: (ctx: ComplexColTypeListContext) => void;
+    enterComplexColType?: (ctx: ComplexColTypeContext) => void;
+    exitComplexColType?: (ctx: ComplexColTypeContext) => void;
+    enterWhenClause?: (ctx: WhenClauseContext) => void;
+    exitWhenClause?: (ctx: WhenClauseContext) => void;
+    enterWindowClause?: (ctx: WindowClauseContext) => void;
+    exitWindowClause?: (ctx: WindowClauseContext) => void;
+    enterNamedWindow?: (ctx: NamedWindowContext) => void;
+    exitNamedWindow?: (ctx: NamedWindowContext) => void;
+    enterWindowSpec?: (ctx: WindowSpecContext) => void;
+    exitWindowSpec?: (ctx: WindowSpecContext) => void;
+    enterWindowFrame?: (ctx: WindowFrameContext) => void;
+    exitWindowFrame?: (ctx: WindowFrameContext) => void;
+    enterFrameBound?: (ctx: FrameBoundContext) => void;
+    exitFrameBound?: (ctx: FrameBoundContext) => void;
+    enterQualifiedNameList?: (ctx: QualifiedNameListContext) => void;
+    exitQualifiedNameList?: (ctx: QualifiedNameListContext) => void;
+    enterFunctionName?: (ctx: FunctionNameContext) => void;
+    exitFunctionName?: (ctx: FunctionNameContext) => void;
+    enterQualifiedName?: (ctx: QualifiedNameContext) => void;
+    exitQualifiedName?: (ctx: QualifiedNameContext) => void;
+    enterErrorCapturingIdentifier?: (ctx: ErrorCapturingIdentifierContext) => void;
+    exitErrorCapturingIdentifier?: (ctx: ErrorCapturingIdentifierContext) => void;
+    enterErrorCapturingIdentifierExtra?: (ctx: ErrorCapturingIdentifierExtraContext) => void;
+    exitErrorCapturingIdentifierExtra?: (ctx: ErrorCapturingIdentifierExtraContext) => void;
+    enterIdentifier?: (ctx: IdentifierContext) => void;
+    exitIdentifier?: (ctx: IdentifierContext) => void;
+    enterStrictIdentifier?: (ctx: StrictIdentifierContext) => void;
+    exitStrictIdentifier?: (ctx: StrictIdentifierContext) => void;
+    enterQuotedIdentifier?: (ctx: QuotedIdentifierContext) => void;
+    exitQuotedIdentifier?: (ctx: QuotedIdentifierContext) => void;
+    enterBackQuotedIdentifier?: (ctx: BackQuotedIdentifierContext) => void;
+    exitBackQuotedIdentifier?: (ctx: BackQuotedIdentifierContext) => void;
+    enterNumber?: (ctx: NumberContext) => void;
+    exitNumber?: (ctx: NumberContext) => void;
+    enterAlterColumnAction?: (ctx: AlterColumnActionContext) => void;
+    exitAlterColumnAction?: (ctx: AlterColumnActionContext) => void;
+    enterStringLit?: (ctx: StringLitContext) => void;
+    exitStringLit?: (ctx: StringLitContext) => void;
+    enterComment?: (ctx: CommentContext) => void;
+    exitComment?: (ctx: CommentContext) => void;
+    enterVersion?: (ctx: VersionContext) => void;
+    exitVersion?: (ctx: VersionContext) => void;
+    enterAnsiNonReserved?: (ctx: AnsiNonReservedContext) => void;
+    exitAnsiNonReserved?: (ctx: AnsiNonReservedContext) => void;
+    enterStrictNonReserved?: (ctx: StrictNonReservedContext) => void;
+    exitStrictNonReserved?: (ctx: StrictNonReservedContext) => void;
+    enterNonReserved?: (ctx: NonReservedContext) => void;
+    exitNonReserved?: (ctx: NonReservedContext) => void;
+}