package com.chenyang.druid.sql.dialect.es.ast;

import org.antlr.v4.runtime.tree.ParseTreeListener;

public interface EsParserListener extends ParseTreeListener {
   void enterStatement(EsParser.StatementContext var1);

   void exitStatement(EsParser.StatementContext var1);

   void enterOtherStatement(EsParser.OtherStatementContext var1);

   void exitOtherStatement(EsParser.OtherStatementContext var1);

   void enterCreateIndexStatement(EsParser.CreateIndexStatementContext var1);

   void exitCreateIndexStatement(EsParser.CreateIndexStatementContext var1);

   void enterCreateIndexStatementBody(EsParser.CreateIndexStatementBodyContext var1);

   void exitCreateIndexStatementBody(EsParser.CreateIndexStatementBodyContext var1);

   void enterCreateIndexStatementAliases(EsParser.CreateIndexStatementAliasesContext var1);

   void exitCreateIndexStatementAliases(EsParser.CreateIndexStatementAliasesContext var1);

   void enterCreateIndexStatementSettings(EsParser.CreateIndexStatementSettingsContext var1);

   void exitCreateIndexStatementSettings(EsParser.CreateIndexStatementSettingsContext var1);

   void enterCreateIndexStatementMeta(EsParser.CreateIndexStatementMetaContext var1);

   void exitCreateIndexStatementMeta(EsParser.CreateIndexStatementMetaContext var1);

   void enterCreateIndexStatementMappings(EsParser.CreateIndexStatementMappingsContext var1);

   void exitCreateIndexStatementMappings(EsParser.CreateIndexStatementMappingsContext var1);

   void enterCreateIndexStatementMappingsType(EsParser.CreateIndexStatementMappingsTypeContext var1);

   void exitCreateIndexStatementMappingsType(EsParser.CreateIndexStatementMappingsTypeContext var1);

   void enterUpdateIndexStatement(EsParser.UpdateIndexStatementContext var1);

   void exitUpdateIndexStatement(EsParser.UpdateIndexStatementContext var1);

   void enterUpdateMappingStatementBody(EsParser.UpdateMappingStatementBodyContext var1);

   void exitUpdateMappingStatementBody(EsParser.UpdateMappingStatementBodyContext var1);

   void enterDeleteIndexStatement(EsParser.DeleteIndexStatementContext var1);

   void exitDeleteIndexStatement(EsParser.DeleteIndexStatementContext var1);

   void enterCloseIndexStatement(EsParser.CloseIndexStatementContext var1);

   void exitCloseIndexStatement(EsParser.CloseIndexStatementContext var1);

   void enterOpenIndexStatement(EsParser.OpenIndexStatementContext var1);

   void exitOpenIndexStatement(EsParser.OpenIndexStatementContext var1);

   void enterShrinkIndexStatement(EsParser.ShrinkIndexStatementContext var1);

   void exitShrinkIndexStatement(EsParser.ShrinkIndexStatementContext var1);

   void enterCloneIndexStatement(EsParser.CloneIndexStatementContext var1);

   void exitCloneIndexStatement(EsParser.CloneIndexStatementContext var1);

   void enterRolloverIndexStatement(EsParser.RolloverIndexStatementContext var1);

   void exitRolloverIndexStatement(EsParser.RolloverIndexStatementContext var1);

   void enterUnfreezeIndexStatement(EsParser.UnfreezeIndexStatementContext var1);

   void exitUnfreezeIndexStatement(EsParser.UnfreezeIndexStatementContext var1);

   void enterFreezeIndexStatement(EsParser.FreezeIndexStatementContext var1);

   void exitFreezeIndexStatement(EsParser.FreezeIndexStatementContext var1);

   void enterResloveIndexStatement(EsParser.ResloveIndexStatementContext var1);

   void exitResloveIndexStatement(EsParser.ResloveIndexStatementContext var1);

   void enterQueryDataRenderStatement(EsParser.QueryDataRenderStatementContext var1);

   void exitQueryDataRenderStatement(EsParser.QueryDataRenderStatementContext var1);

   void enterQueryDataSearchShardsStatement(EsParser.QueryDataSearchShardsStatementContext var1);

   void exitQueryDataSearchShardsStatement(EsParser.QueryDataSearchShardsStatementContext var1);

   void enterDdlMappingProperties(EsParser.DdlMappingPropertiesContext var1);

   void exitDdlMappingProperties(EsParser.DdlMappingPropertiesContext var1);

   void enterDdlMappingPropertiesDynamic(EsParser.DdlMappingPropertiesDynamicContext var1);

   void exitDdlMappingPropertiesDynamic(EsParser.DdlMappingPropertiesDynamicContext var1);

   void enterDdlMappingPropertiesDynamicTemplates(EsParser.DdlMappingPropertiesDynamicTemplatesContext var1);

   void exitDdlMappingPropertiesDynamicTemplates(EsParser.DdlMappingPropertiesDynamicTemplatesContext var1);

   void enterDdlMappingPropertiesAll(EsParser.DdlMappingPropertiesAllContext var1);

   void exitDdlMappingPropertiesAll(EsParser.DdlMappingPropertiesAllContext var1);

   void enterDdlMappingPropertiesDefine(EsParser.DdlMappingPropertiesDefineContext var1);

   void exitDdlMappingPropertiesDefine(EsParser.DdlMappingPropertiesDefineContext var1);

   void enterDdlFieldDecl(EsParser.DdlFieldDeclContext var1);

   void exitDdlFieldDecl(EsParser.DdlFieldDeclContext var1);

   void enterDdlField(EsParser.DdlFieldContext var1);

   void exitDdlField(EsParser.DdlFieldContext var1);

   void enterDdlFieldType(EsParser.DdlFieldTypeContext var1);

   void exitDdlFieldType(EsParser.DdlFieldTypeContext var1);

   void enterQuerySchemaStatement(EsParser.QuerySchemaStatementContext var1);

   void exitQuerySchemaStatement(EsParser.QuerySchemaStatementContext var1);

   void enterQuerySchemaStatementALL(EsParser.QuerySchemaStatementALLContext var1);

   void exitQuerySchemaStatementALL(EsParser.QuerySchemaStatementALLContext var1);

   void enterQuerySchemaStatementIndex(EsParser.QuerySchemaStatementIndexContext var1);

   void exitQuerySchemaStatementIndex(EsParser.QuerySchemaStatementIndexContext var1);

   void enterBulkStatement(EsParser.BulkStatementContext var1);

   void exitBulkStatement(EsParser.BulkStatementContext var1);

   void enterBulkStatementBody(EsParser.BulkStatementBodyContext var1);

   void exitBulkStatementBody(EsParser.BulkStatementBodyContext var1);

   void enterBulkStatementCreate(EsParser.BulkStatementCreateContext var1);

   void exitBulkStatementCreate(EsParser.BulkStatementCreateContext var1);

   void enterBulkStatementDelete(EsParser.BulkStatementDeleteContext var1);

   void exitBulkStatementDelete(EsParser.BulkStatementDeleteContext var1);

   void enterBulkStatementIndex(EsParser.BulkStatementIndexContext var1);

   void exitBulkStatementIndex(EsParser.BulkStatementIndexContext var1);

   void enterBulkStatementUpdate(EsParser.BulkStatementUpdateContext var1);

   void exitBulkStatementUpdate(EsParser.BulkStatementUpdateContext var1);

   void enterBulkStatementDoc(EsParser.BulkStatementDocContext var1);

   void exitBulkStatementDoc(EsParser.BulkStatementDocContext var1);

   void enterBulkStatementDocItemSource(EsParser.BulkStatementDocItemSourceContext var1);

   void exitBulkStatementDocItemSource(EsParser.BulkStatementDocItemSourceContext var1);

   void enterBulkStatementDocItem(EsParser.BulkStatementDocItemContext var1);

   void exitBulkStatementDocItem(EsParser.BulkStatementDocItemContext var1);

   void enterBulkStatementDocItemField(EsParser.BulkStatementDocItemFieldContext var1);

   void exitBulkStatementDocItemField(EsParser.BulkStatementDocItemFieldContext var1);

   void enterBulkStatementFields(EsParser.BulkStatementFieldsContext var1);

   void exitBulkStatementFields(EsParser.BulkStatementFieldsContext var1);

   void enterBulkStatementScript(EsParser.BulkStatementScriptContext var1);

   void exitBulkStatementScript(EsParser.BulkStatementScriptContext var1);

   void enterBulkStatementIndexPart(EsParser.BulkStatementIndexPartContext var1);

   void exitBulkStatementIndexPart(EsParser.BulkStatementIndexPartContext var1);

   void enterBulkStatementIdPart(EsParser.BulkStatementIdPartContext var1);

   void exitBulkStatementIdPart(EsParser.BulkStatementIdPartContext var1);

   void enterQueryDataStatement(EsParser.QueryDataStatementContext var1);

   void exitQueryDataStatement(EsParser.QueryDataStatementContext var1);

   void enterQueryDataStatementById(EsParser.QueryDataStatementByIdContext var1);

   void exitQueryDataStatementById(EsParser.QueryDataStatementByIdContext var1);

   void enterQueryDataStatementMGET(EsParser.QueryDataStatementMGETContext var1);

   void exitQueryDataStatementMGET(EsParser.QueryDataStatementMGETContext var1);

   void enterQueryDataStatementMGETBody(EsParser.QueryDataStatementMGETBodyContext var1);

   void exitQueryDataStatementMGETBody(EsParser.QueryDataStatementMGETBodyContext var1);

   void enterQueryDataStatementMGETDocs(EsParser.QueryDataStatementMGETDocsContext var1);

   void exitQueryDataStatementMGETDocs(EsParser.QueryDataStatementMGETDocsContext var1);

   void enterQueryDataStatementMGETDoc(EsParser.QueryDataStatementMGETDocContext var1);

   void exitQueryDataStatementMGETDoc(EsParser.QueryDataStatementMGETDocContext var1);

   void enterQueryDataStatementMGETDocId(EsParser.QueryDataStatementMGETDocIdContext var1);

   void exitQueryDataStatementMGETDocId(EsParser.QueryDataStatementMGETDocIdContext var1);

   void enterQueryDataStatementMGETDocIndex(EsParser.QueryDataStatementMGETDocIndexContext var1);

   void exitQueryDataStatementMGETDocIndex(EsParser.QueryDataStatementMGETDocIndexContext var1);

   void enterQueryDataStatementMGETDocType(EsParser.QueryDataStatementMGETDocTypeContext var1);

   void exitQueryDataStatementMGETDocType(EsParser.QueryDataStatementMGETDocTypeContext var1);

   void enterQueryDataStatementMGETDocSource(EsParser.QueryDataStatementMGETDocSourceContext var1);

   void exitQueryDataStatementMGETDocSource(EsParser.QueryDataStatementMGETDocSourceContext var1);

   void enterQueryDataStatementMGETDocSourceBoolean(EsParser.QueryDataStatementMGETDocSourceBooleanContext var1);

   void exitQueryDataStatementMGETDocSourceBoolean(EsParser.QueryDataStatementMGETDocSourceBooleanContext var1);

   void enterQueryDataStatementMGETDocSourceArr(EsParser.QueryDataStatementMGETDocSourceArrContext var1);

   void exitQueryDataStatementMGETDocSourceArr(EsParser.QueryDataStatementMGETDocSourceArrContext var1);

   void enterQueryDataStatementMGETDocSourceObj(EsParser.QueryDataStatementMGETDocSourceObjContext var1);

   void exitQueryDataStatementMGETDocSourceObj(EsParser.QueryDataStatementMGETDocSourceObjContext var1);

   void enterQueryDataStatementMGETDocIncldue(EsParser.QueryDataStatementMGETDocIncldueContext var1);

   void exitQueryDataStatementMGETDocIncldue(EsParser.QueryDataStatementMGETDocIncldueContext var1);

   void enterQueryDataStatementMGETDocExclude(EsParser.QueryDataStatementMGETDocExcludeContext var1);

   void exitQueryDataStatementMGETDocExclude(EsParser.QueryDataStatementMGETDocExcludeContext var1);

   void enterQueryDataStatementMGETStoredFields(EsParser.QueryDataStatementMGETStoredFieldsContext var1);

   void exitQueryDataStatementMGETStoredFields(EsParser.QueryDataStatementMGETStoredFieldsContext var1);

   void enterQueryDataStatementMGETIds(EsParser.QueryDataStatementMGETIdsContext var1);

   void exitQueryDataStatementMGETIds(EsParser.QueryDataStatementMGETIdsContext var1);

   void enterQueryDataStatementMSearch(EsParser.QueryDataStatementMSearchContext var1);

   void exitQueryDataStatementMSearch(EsParser.QueryDataStatementMSearchContext var1);

   void enterQueryDataStatementMSearchBody(EsParser.QueryDataStatementMSearchBodyContext var1);

   void exitQueryDataStatementMSearchBody(EsParser.QueryDataStatementMSearchBodyContext var1);

   void enterQueryDataStatementMSearchEmpty(EsParser.QueryDataStatementMSearchEmptyContext var1);

   void exitQueryDataStatementMSearchEmpty(EsParser.QueryDataStatementMSearchEmptyContext var1);

   void enterQueryDataStatementCount(EsParser.QueryDataStatementCountContext var1);

   void exitQueryDataStatementCount(EsParser.QueryDataStatementCountContext var1);

   void enterQueryDataStatementCountBody(EsParser.QueryDataStatementCountBodyContext var1);

   void exitQueryDataStatementCountBody(EsParser.QueryDataStatementCountBodyContext var1);

   void enterQueryDataStatementTermsEnum(EsParser.QueryDataStatementTermsEnumContext var1);

   void exitQueryDataStatementTermsEnum(EsParser.QueryDataStatementTermsEnumContext var1);

   void enterQueryDataStatementTermsEnumBody(EsParser.QueryDataStatementTermsEnumBodyContext var1);

   void exitQueryDataStatementTermsEnumBody(EsParser.QueryDataStatementTermsEnumBodyContext var1);

   void enterQueryDataStatementTermsEnumField(EsParser.QueryDataStatementTermsEnumFieldContext var1);

   void exitQueryDataStatementTermsEnumField(EsParser.QueryDataStatementTermsEnumFieldContext var1);

   void enterQueryDataStatementTermsEnumValue(EsParser.QueryDataStatementTermsEnumValueContext var1);

   void exitQueryDataStatementTermsEnumValue(EsParser.QueryDataStatementTermsEnumValueContext var1);

   void enterQueryDataStatementExplain(EsParser.QueryDataStatementExplainContext var1);

   void exitQueryDataStatementExplain(EsParser.QueryDataStatementExplainContext var1);

   void enterQueryDataStatementExplainBody(EsParser.QueryDataStatementExplainBodyContext var1);

   void exitQueryDataStatementExplainBody(EsParser.QueryDataStatementExplainBodyContext var1);

   void enterQueryDataStatementFieldCaps(EsParser.QueryDataStatementFieldCapsContext var1);

   void exitQueryDataStatementFieldCaps(EsParser.QueryDataStatementFieldCapsContext var1);

   void enterQueryDataStatementFieldCapsBody(EsParser.QueryDataStatementFieldCapsBodyContext var1);

   void exitQueryDataStatementFieldCapsBody(EsParser.QueryDataStatementFieldCapsBodyContext var1);

   void enterQueryDataStatementFieldCapsBodyIndexFiter(EsParser.QueryDataStatementFieldCapsBodyIndexFiterContext var1);

   void exitQueryDataStatementFieldCapsBodyIndexFiter(EsParser.QueryDataStatementFieldCapsBodyIndexFiterContext var1);

   void enterQueryDataStatementRankEval(EsParser.QueryDataStatementRankEvalContext var1);

   void exitQueryDataStatementRankEval(EsParser.QueryDataStatementRankEvalContext var1);

   void enterQueryDataStatementRankEvalBody(EsParser.QueryDataStatementRankEvalBodyContext var1);

   void exitQueryDataStatementRankEvalBody(EsParser.QueryDataStatementRankEvalBodyContext var1);

   void enterQueryDataStatementRankEvalRequests(EsParser.QueryDataStatementRankEvalRequestsContext var1);

   void exitQueryDataStatementRankEvalRequests(EsParser.QueryDataStatementRankEvalRequestsContext var1);

   void enterQueryDataStatementRankEvalRequestBody(EsParser.QueryDataStatementRankEvalRequestBodyContext var1);

   void exitQueryDataStatementRankEvalRequestBody(EsParser.QueryDataStatementRankEvalRequestBodyContext var1);

   void enterQueryDataStatementRankEvalRequest(EsParser.QueryDataStatementRankEvalRequestContext var1);

   void exitQueryDataStatementRankEvalRequest(EsParser.QueryDataStatementRankEvalRequestContext var1);

   void enterQueryDataStatementRankEvalRatings(EsParser.QueryDataStatementRankEvalRatingsContext var1);

   void exitQueryDataStatementRankEvalRatings(EsParser.QueryDataStatementRankEvalRatingsContext var1);

   void enterQueryDataStatementRankEvalRating(EsParser.QueryDataStatementRankEvalRatingContext var1);

   void exitQueryDataStatementRankEvalRating(EsParser.QueryDataStatementRankEvalRatingContext var1);

   void enterQueryDataStatementRankEvalRatingIndex(EsParser.QueryDataStatementRankEvalRatingIndexContext var1);

   void exitQueryDataStatementRankEvalRatingIndex(EsParser.QueryDataStatementRankEvalRatingIndexContext var1);

   void enterQueryDataStatementRankEvalRatingId(EsParser.QueryDataStatementRankEvalRatingIdContext var1);

   void exitQueryDataStatementRankEvalRatingId(EsParser.QueryDataStatementRankEvalRatingIdContext var1);

   void enterQueryDataStatementSearch(EsParser.QueryDataStatementSearchContext var1);

   void exitQueryDataStatementSearch(EsParser.QueryDataStatementSearchContext var1);

   void enterQueryDataStatementSearchBody(EsParser.QueryDataStatementSearchBodyContext var1);

   void exitQueryDataStatementSearchBody(EsParser.QueryDataStatementSearchBodyContext var1);

   void enterQueryDataStatementSearchBodyDocValueFields(EsParser.QueryDataStatementSearchBodyDocValueFieldsContext var1);

   void exitQueryDataStatementSearchBodyDocValueFields(EsParser.QueryDataStatementSearchBodyDocValueFieldsContext var1);

   void enterFieldExpr(EsParser.FieldExprContext var1);

   void exitFieldExpr(EsParser.FieldExprContext var1);

   void enterField(EsParser.FieldContext var1);

   void exitField(EsParser.FieldContext var1);

   void enterFieldString(EsParser.FieldStringContext var1);

   void exitFieldString(EsParser.FieldStringContext var1);

   void enterFieldObj(EsParser.FieldObjContext var1);

   void exitFieldObj(EsParser.FieldObjContext var1);

   void enterQueryDataStatementSearchBodyStoredFields(EsParser.QueryDataStatementSearchBodyStoredFieldsContext var1);

   void exitQueryDataStatementSearchBodyStoredFields(EsParser.QueryDataStatementSearchBodyStoredFieldsContext var1);

   void enterQueryDataStatementSearchBodyIndicesBoost(EsParser.QueryDataStatementSearchBodyIndicesBoostContext var1);

   void exitQueryDataStatementSearchBodyIndicesBoost(EsParser.QueryDataStatementSearchBodyIndicesBoostContext var1);

   void enterQueryDataStatementSearchBodyIndicesBoostItem(EsParser.QueryDataStatementSearchBodyIndicesBoostItemContext var1);

   void exitQueryDataStatementSearchBodyIndicesBoostItem(EsParser.QueryDataStatementSearchBodyIndicesBoostItemContext var1);

   void enterQueryDataStatementSearchBodyIndexTypes(EsParser.QueryDataStatementSearchBodyIndexTypesContext var1);

   void exitQueryDataStatementSearchBodyIndexTypes(EsParser.QueryDataStatementSearchBodyIndexTypesContext var1);

   void enterQueryDataStatementSearchBodyIndex(EsParser.QueryDataStatementSearchBodyIndexContext var1);

   void exitQueryDataStatementSearchBodyIndex(EsParser.QueryDataStatementSearchBodyIndexContext var1);

   void enterQueryDataStatementSearchBodyType(EsParser.QueryDataStatementSearchBodyTypeContext var1);

   void exitQueryDataStatementSearchBodyType(EsParser.QueryDataStatementSearchBodyTypeContext var1);

   void enterQueryDataStatementSearchBodyRuntimeMappings(EsParser.QueryDataStatementSearchBodyRuntimeMappingsContext var1);

   void exitQueryDataStatementSearchBodyRuntimeMappings(EsParser.QueryDataStatementSearchBodyRuntimeMappingsContext var1);

   void enterQueryDataStatementSearchBodyRuntimeMappingObj(EsParser.QueryDataStatementSearchBodyRuntimeMappingObjContext var1);

   void exitQueryDataStatementSearchBodyRuntimeMappingObj(EsParser.QueryDataStatementSearchBodyRuntimeMappingObjContext var1);

   void enterQueryDataStatementSearchBodyRuntimeMappingObjFieldExpr(EsParser.QueryDataStatementSearchBodyRuntimeMappingObjFieldExprContext var1);

   void exitQueryDataStatementSearchBodyRuntimeMappingObjFieldExpr(EsParser.QueryDataStatementSearchBodyRuntimeMappingObjFieldExprContext var1);

   void enterQueryDataStatementSearchBodyRuntimeMappingObjFieldExprType(EsParser.QueryDataStatementSearchBodyRuntimeMappingObjFieldExprTypeContext var1);

   void exitQueryDataStatementSearchBodyRuntimeMappingObjFieldExprType(EsParser.QueryDataStatementSearchBodyRuntimeMappingObjFieldExprTypeContext var1);

   void enterQueryDataStatementSearchBodyRuntimeMappingObjFieldExprScript(EsParser.QueryDataStatementSearchBodyRuntimeMappingObjFieldExprScriptContext var1);

   void exitQueryDataStatementSearchBodyRuntimeMappingObjFieldExprScript(EsParser.QueryDataStatementSearchBodyRuntimeMappingObjFieldExprScriptContext var1);

   void enterQueryDataStatementSearchBodyRuntimeMappingsArr(EsParser.QueryDataStatementSearchBodyRuntimeMappingsArrContext var1);

   void exitQueryDataStatementSearchBodyRuntimeMappingsArr(EsParser.QueryDataStatementSearchBodyRuntimeMappingsArrContext var1);

   void enterRunTimeMappingFieldExprs(EsParser.RunTimeMappingFieldExprsContext var1);

   void exitRunTimeMappingFieldExprs(EsParser.RunTimeMappingFieldExprsContext var1);

   void enterRuntimeMappingField(EsParser.RuntimeMappingFieldContext var1);

   void exitRuntimeMappingField(EsParser.RuntimeMappingFieldContext var1);

   void enterQueryDataStatementSearchBodyQuery(EsParser.QueryDataStatementSearchBodyQueryContext var1);

   void exitQueryDataStatementSearchBodyQuery(EsParser.QueryDataStatementSearchBodyQueryContext var1);

   void enterQueryDataStatementSearchBodyFields(EsParser.QueryDataStatementSearchBodyFieldsContext var1);

   void exitQueryDataStatementSearchBodyFields(EsParser.QueryDataStatementSearchBodyFieldsContext var1);

   void enterQueryDataStatementSearchBodyAgg(EsParser.QueryDataStatementSearchBodyAggContext var1);

   void exitQueryDataStatementSearchBodyAgg(EsParser.QueryDataStatementSearchBodyAggContext var1);

   void enterQueryDataStatementSearchBodyAggBody(EsParser.QueryDataStatementSearchBodyAggBodyContext var1);

   void exitQueryDataStatementSearchBodyAggBody(EsParser.QueryDataStatementSearchBodyAggBodyContext var1);

   void enterQueryDataStatementSearchSort(EsParser.QueryDataStatementSearchSortContext var1);

   void exitQueryDataStatementSearchSort(EsParser.QueryDataStatementSearchSortContext var1);

   void enterSortField(EsParser.SortFieldContext var1);

   void exitSortField(EsParser.SortFieldContext var1);

   void enterQueryDataStatementSearchBodySource(EsParser.QueryDataStatementSearchBodySourceContext var1);

   void exitQueryDataStatementSearchBodySource(EsParser.QueryDataStatementSearchBodySourceContext var1);

   void enterSourceFieldExpr(EsParser.SourceFieldExprContext var1);

   void exitSourceFieldExpr(EsParser.SourceFieldExprContext var1);

   void enterSourceFieldBoolenExpr(EsParser.SourceFieldBoolenExprContext var1);

   void exitSourceFieldBoolenExpr(EsParser.SourceFieldBoolenExprContext var1);

   void enterSourceFieldWildcardPatternExpr(EsParser.SourceFieldWildcardPatternExprContext var1);

   void exitSourceFieldWildcardPatternExpr(EsParser.SourceFieldWildcardPatternExprContext var1);

   void enterSourceFieldObjectExpr(EsParser.SourceFieldObjectExprContext var1);

   void exitSourceFieldObjectExpr(EsParser.SourceFieldObjectExprContext var1);

   void enterSourceFieldIncludeExpr(EsParser.SourceFieldIncludeExprContext var1);

   void exitSourceFieldIncludeExpr(EsParser.SourceFieldIncludeExprContext var1);

   void enterSourceFieldExcludeExpr(EsParser.SourceFieldExcludeExprContext var1);

   void exitSourceFieldExcludeExpr(EsParser.SourceFieldExcludeExprContext var1);

   void enterInsertDataStatement(EsParser.InsertDataStatementContext var1);

   void exitInsertDataStatement(EsParser.InsertDataStatementContext var1);

   void enterInsertDataStatementForm1(EsParser.InsertDataStatementForm1Context var1);

   void exitInsertDataStatementForm1(EsParser.InsertDataStatementForm1Context var1);

   void enterInsertDataStatementForm2(EsParser.InsertDataStatementForm2Context var1);

   void exitInsertDataStatementForm2(EsParser.InsertDataStatementForm2Context var1);

   void enterUpdateDataStatement(EsParser.UpdateDataStatementContext var1);

   void exitUpdateDataStatement(EsParser.UpdateDataStatementContext var1);

   void enterUpdateDataStatementById(EsParser.UpdateDataStatementByIdContext var1);

   void exitUpdateDataStatementById(EsParser.UpdateDataStatementByIdContext var1);

   void enterUpdateDataStatementPart1(EsParser.UpdateDataStatementPart1Context var1);

   void exitUpdateDataStatementPart1(EsParser.UpdateDataStatementPart1Context var1);

   void enterUpdateDataStatementPart2(EsParser.UpdateDataStatementPart2Context var1);

   void exitUpdateDataStatementPart2(EsParser.UpdateDataStatementPart2Context var1);

   void enterUpdateDataStatementByQuery(EsParser.UpdateDataStatementByQueryContext var1);

   void exitUpdateDataStatementByQuery(EsParser.UpdateDataStatementByQueryContext var1);

   void enterUpdateDataStatementByQueryBody(EsParser.UpdateDataStatementByQueryBodyContext var1);

   void exitUpdateDataStatementByQueryBody(EsParser.UpdateDataStatementByQueryBodyContext var1);

   void enterDeleteDataStatement(EsParser.DeleteDataStatementContext var1);

   void exitDeleteDataStatement(EsParser.DeleteDataStatementContext var1);

   void enterDeleteDataByIdStatement(EsParser.DeleteDataByIdStatementContext var1);

   void exitDeleteDataByIdStatement(EsParser.DeleteDataByIdStatementContext var1);

   void enterDeleteDataByQueryStatement(EsParser.DeleteDataByQueryStatementContext var1);

   void exitDeleteDataByQueryStatement(EsParser.DeleteDataByQueryStatementContext var1);

   void enterCuDataStatementBody(EsParser.CuDataStatementBodyContext var1);

   void exitCuDataStatementBody(EsParser.CuDataStatementBodyContext var1);

   void enterCuDataStatementValue(EsParser.CuDataStatementValueContext var1);

   void exitCuDataStatementValue(EsParser.CuDataStatementValueContext var1);

   void enterCuDataStatementObjValue(EsParser.CuDataStatementObjValueContext var1);

   void exitCuDataStatementObjValue(EsParser.CuDataStatementObjValueContext var1);

   void enterCuDataStatementArrayValue(EsParser.CuDataStatementArrayValueContext var1);

   void exitCuDataStatementArrayValue(EsParser.CuDataStatementArrayValueContext var1);

   void enterCuDataStatementObjValuePair(EsParser.CuDataStatementObjValuePairContext var1);

   void exitCuDataStatementObjValuePair(EsParser.CuDataStatementObjValuePairContext var1);

   void enterCuDataStatementFieldScript(EsParser.CuDataStatementFieldScriptContext var1);

   void exitCuDataStatementFieldScript(EsParser.CuDataStatementFieldScriptContext var1);

   void enterQueryBody(EsParser.QueryBodyContext var1);

   void exitQueryBody(EsParser.QueryBodyContext var1);

   void enterQueryFilter(EsParser.QueryFilterContext var1);

   void exitQueryFilter(EsParser.QueryFilterContext var1);

   void enterComboundFilter(EsParser.ComboundFilterContext var1);

   void exitComboundFilter(EsParser.ComboundFilterContext var1);

   void enterNsetedFilter(EsParser.NsetedFilterContext var1);

   void exitNsetedFilter(EsParser.NsetedFilterContext var1);

   void enterNsetedFilterItem(EsParser.NsetedFilterItemContext var1);

   void exitNsetedFilterItem(EsParser.NsetedFilterItemContext var1);

   void enterNsetedFilterItemPath(EsParser.NsetedFilterItemPathContext var1);

   void exitNsetedFilterItemPath(EsParser.NsetedFilterItemPathContext var1);

   void enterBoostingFilter(EsParser.BoostingFilterContext var1);

   void exitBoostingFilter(EsParser.BoostingFilterContext var1);

   void enterBoostingFilterBody(EsParser.BoostingFilterBodyContext var1);

   void exitBoostingFilterBody(EsParser.BoostingFilterBodyContext var1);

   void enterHasChildFilter(EsParser.HasChildFilterContext var1);

   void exitHasChildFilter(EsParser.HasChildFilterContext var1);

   void enterHasParentFilter(EsParser.HasParentFilterContext var1);

   void exitHasParentFilter(EsParser.HasParentFilterContext var1);

   void enterParentIdFilter(EsParser.ParentIdFilterContext var1);

   void exitParentIdFilter(EsParser.ParentIdFilterContext var1);

   void enterBoolFilter(EsParser.BoolFilterContext var1);

   void exitBoolFilter(EsParser.BoolFilterContext var1);

   void enterMustFilter(EsParser.MustFilterContext var1);

   void exitMustFilter(EsParser.MustFilterContext var1);

   void enterMustFilterN(EsParser.MustFilterNContext var1);

   void exitMustFilterN(EsParser.MustFilterNContext var1);

   void enterMustFilter1(EsParser.MustFilter1Context var1);

   void exitMustFilter1(EsParser.MustFilter1Context var1);

   void enterFilterFilter(EsParser.FilterFilterContext var1);

   void exitFilterFilter(EsParser.FilterFilterContext var1);

   void enterFilterFilterN(EsParser.FilterFilterNContext var1);

   void exitFilterFilterN(EsParser.FilterFilterNContext var1);

   void enterFilterFilter1(EsParser.FilterFilter1Context var1);

   void exitFilterFilter1(EsParser.FilterFilter1Context var1);

   void enterShouldFilter(EsParser.ShouldFilterContext var1);

   void exitShouldFilter(EsParser.ShouldFilterContext var1);

   void enterShouldFilterN(EsParser.ShouldFilterNContext var1);

   void exitShouldFilterN(EsParser.ShouldFilterNContext var1);

   void enterShouldFilter1(EsParser.ShouldFilter1Context var1);

   void exitShouldFilter1(EsParser.ShouldFilter1Context var1);

   void enterConstantScoreFilter(EsParser.ConstantScoreFilterContext var1);

   void exitConstantScoreFilter(EsParser.ConstantScoreFilterContext var1);

   void enterDismaxFilter(EsParser.DismaxFilterContext var1);

   void exitDismaxFilter(EsParser.DismaxFilterContext var1);

   void enterDismaxFilterQueriesBody(EsParser.DismaxFilterQueriesBodyContext var1);

   void exitDismaxFilterQueriesBody(EsParser.DismaxFilterQueriesBodyContext var1);

   void enterDismaxFilterQueriesBodyItems(EsParser.DismaxFilterQueriesBodyItemsContext var1);

   void exitDismaxFilterQueriesBodyItems(EsParser.DismaxFilterQueriesBodyItemsContext var1);

   void enterFunctionScoreFilter(EsParser.FunctionScoreFilterContext var1);

   void exitFunctionScoreFilter(EsParser.FunctionScoreFilterContext var1);

   void enterLeafFilter(EsParser.LeafFilterContext var1);

   void exitLeafFilter(EsParser.LeafFilterContext var1);

   void enterLeafMatchAllFilter(EsParser.LeafMatchAllFilterContext var1);

   void exitLeafMatchAllFilter(EsParser.LeafMatchAllFilterContext var1);

   void enterLeafMatchNoneFilter(EsParser.LeafMatchNoneFilterContext var1);

   void exitLeafMatchNoneFilter(EsParser.LeafMatchNoneFilterContext var1);

   void enterLeafMatchFilter(EsParser.LeafMatchFilterContext var1);

   void exitLeafMatchFilter(EsParser.LeafMatchFilterContext var1);

   void enterIntervalFilter(EsParser.IntervalFilterContext var1);

   void exitIntervalFilter(EsParser.IntervalFilterContext var1);

   void enterIntervalFilterRuleAnyOf(EsParser.IntervalFilterRuleAnyOfContext var1);

   void exitIntervalFilterRuleAnyOf(EsParser.IntervalFilterRuleAnyOfContext var1);

   void enterIntervalFilterRuleAllOf(EsParser.IntervalFilterRuleAllOfContext var1);

   void exitIntervalFilterRuleAllOf(EsParser.IntervalFilterRuleAllOfContext var1);

   void enterIntervalFilterRuleMatch(EsParser.IntervalFilterRuleMatchContext var1);

   void exitIntervalFilterRuleMatch(EsParser.IntervalFilterRuleMatchContext var1);

   void enterIntervalFilterRuleMatchQuery(EsParser.IntervalFilterRuleMatchQueryContext var1);

   void exitIntervalFilterRuleMatchQuery(EsParser.IntervalFilterRuleMatchQueryContext var1);

   void enterIntervalFilterRuleMatchUseField(EsParser.IntervalFilterRuleMatchUseFieldContext var1);

   void exitIntervalFilterRuleMatchUseField(EsParser.IntervalFilterRuleMatchUseFieldContext var1);

   void enterIntervalFilterRulePrefix(EsParser.IntervalFilterRulePrefixContext var1);

   void exitIntervalFilterRulePrefix(EsParser.IntervalFilterRulePrefixContext var1);

   void enterIntervalFilterRulePrefixPrefix(EsParser.IntervalFilterRulePrefixPrefixContext var1);

   void exitIntervalFilterRulePrefixPrefix(EsParser.IntervalFilterRulePrefixPrefixContext var1);

   void enterIntervalFilterRuleWildcard(EsParser.IntervalFilterRuleWildcardContext var1);

   void exitIntervalFilterRuleWildcard(EsParser.IntervalFilterRuleWildcardContext var1);

   void enterIntervalFilterRuleWildcardPattern(EsParser.IntervalFilterRuleWildcardPatternContext var1);

   void exitIntervalFilterRuleWildcardPattern(EsParser.IntervalFilterRuleWildcardPatternContext var1);

   void enterIntervalFilterRuleFuzzy(EsParser.IntervalFilterRuleFuzzyContext var1);

   void exitIntervalFilterRuleFuzzy(EsParser.IntervalFilterRuleFuzzyContext var1);

   void enterIntervalFilterRuleFilter(EsParser.IntervalFilterRuleFilterContext var1);

   void exitIntervalFilterRuleFilter(EsParser.IntervalFilterRuleFilterContext var1);

   void enterIntervalFilterRuleInterval(EsParser.IntervalFilterRuleIntervalContext var1);

   void exitIntervalFilterRuleInterval(EsParser.IntervalFilterRuleIntervalContext var1);

   void enterIntervalFilterItem(EsParser.IntervalFilterItemContext var1);

   void exitIntervalFilterItem(EsParser.IntervalFilterItemContext var1);

   void enterIntervalFilterIntervalItem(EsParser.IntervalFilterIntervalItemContext var1);

   void exitIntervalFilterIntervalItem(EsParser.IntervalFilterIntervalItemContext var1);

   void enterIntervalFilterIntervalRuleAnyOf(EsParser.IntervalFilterIntervalRuleAnyOfContext var1);

   void exitIntervalFilterIntervalRuleAnyOf(EsParser.IntervalFilterIntervalRuleAnyOfContext var1);

   void enterIntervalFilterIntervalRuleAllOf(EsParser.IntervalFilterIntervalRuleAllOfContext var1);

   void exitIntervalFilterIntervalRuleAllOf(EsParser.IntervalFilterIntervalRuleAllOfContext var1);

   void enterIntervalFilterIntervalRuleMatch(EsParser.IntervalFilterIntervalRuleMatchContext var1);

   void exitIntervalFilterIntervalRuleMatch(EsParser.IntervalFilterIntervalRuleMatchContext var1);

   void enterIntervalFilterIntervalRulePrefix(EsParser.IntervalFilterIntervalRulePrefixContext var1);

   void exitIntervalFilterIntervalRulePrefix(EsParser.IntervalFilterIntervalRulePrefixContext var1);

   void enterIntervalFilterIntervalRuleWildcard(EsParser.IntervalFilterIntervalRuleWildcardContext var1);

   void exitIntervalFilterIntervalRuleWildcard(EsParser.IntervalFilterIntervalRuleWildcardContext var1);

   void enterIntervalFilterIntervalRuleFuzzy(EsParser.IntervalFilterIntervalRuleFuzzyContext var1);

   void exitIntervalFilterIntervalRuleFuzzy(EsParser.IntervalFilterIntervalRuleFuzzyContext var1);

   void enterFilterMatch(EsParser.FilterMatchContext var1);

   void exitFilterMatch(EsParser.FilterMatchContext var1);

   void enterFilterMatchBoolPrefix(EsParser.FilterMatchBoolPrefixContext var1);

   void exitFilterMatchBoolPrefix(EsParser.FilterMatchBoolPrefixContext var1);

   void enterFilterMatchPhrase(EsParser.FilterMatchPhraseContext var1);

   void exitFilterMatchPhrase(EsParser.FilterMatchPhraseContext var1);

   void enterFilterMatchPhrasePrefix(EsParser.FilterMatchPhrasePrefixContext var1);

   void exitFilterMatchPhrasePrefix(EsParser.FilterMatchPhrasePrefixContext var1);

   void enterFilterCombinedFields(EsParser.FilterCombinedFieldsContext var1);

   void exitFilterCombinedFields(EsParser.FilterCombinedFieldsContext var1);

   void enterFilterMultiMatch(EsParser.FilterMultiMatchContext var1);

   void exitFilterMultiMatch(EsParser.FilterMultiMatchContext var1);

   void enterFilterCommon(EsParser.FilterCommonContext var1);

   void exitFilterCommon(EsParser.FilterCommonContext var1);

   void enterFilterQueryString(EsParser.FilterQueryStringContext var1);

   void exitFilterQueryString(EsParser.FilterQueryStringContext var1);

   void enterFilterSimpleQueryString(EsParser.FilterSimpleQueryStringContext var1);

   void exitFilterSimpleQueryString(EsParser.FilterSimpleQueryStringContext var1);

   void enterLeafTermFilter(EsParser.LeafTermFilterContext var1);

   void exitLeafTermFilter(EsParser.LeafTermFilterContext var1);

   void enterFilterExists(EsParser.FilterExistsContext var1);

   void exitFilterExists(EsParser.FilterExistsContext var1);

   void enterFilterFuzzy(EsParser.FilterFuzzyContext var1);

   void exitFilterFuzzy(EsParser.FilterFuzzyContext var1);

   void enterFieldFuzzyExactFilter(EsParser.FieldFuzzyExactFilterContext var1);

   void exitFieldFuzzyExactFilter(EsParser.FieldFuzzyExactFilterContext var1);

   void enterFilterTermFilter(EsParser.FilterTermFilterContext var1);

   void exitFilterTermFilter(EsParser.FilterTermFilterContext var1);

   void enterFilterIds(EsParser.FilterIdsContext var1);

   void exitFilterIds(EsParser.FilterIdsContext var1);

   void enterFilterPrefix(EsParser.FilterPrefixContext var1);

   void exitFilterPrefix(EsParser.FilterPrefixContext var1);

   void enterRangeFilter(EsParser.RangeFilterContext var1);

   void exitRangeFilter(EsParser.RangeFilterContext var1);

   void enterRangeFilterGT(EsParser.RangeFilterGTContext var1);

   void exitRangeFilterGT(EsParser.RangeFilterGTContext var1);

   void enterRangeFilterLT(EsParser.RangeFilterLTContext var1);

   void exitRangeFilterLT(EsParser.RangeFilterLTContext var1);

   void enterRegexpFilter(EsParser.RegexpFilterContext var1);

   void exitRegexpFilter(EsParser.RegexpFilterContext var1);

   void enterTermsFilter(EsParser.TermsFilterContext var1);

   void exitTermsFilter(EsParser.TermsFilterContext var1);

   void enterTermsFilterField1(EsParser.TermsFilterField1Context var1);

   void exitTermsFilterField1(EsParser.TermsFilterField1Context var1);

   void enterTermsFilterFieldN(EsParser.TermsFilterFieldNContext var1);

   void exitTermsFilterFieldN(EsParser.TermsFilterFieldNContext var1);

   void enterTermsFilterFieldNItem(EsParser.TermsFilterFieldNItemContext var1);

   void exitTermsFilterFieldNItem(EsParser.TermsFilterFieldNItemContext var1);

   void enterTermsFilterField(EsParser.TermsFilterFieldContext var1);

   void exitTermsFilterField(EsParser.TermsFilterFieldContext var1);

   void enterTermsFilterFieldItem1(EsParser.TermsFilterFieldItem1Context var1);

   void exitTermsFilterFieldItem1(EsParser.TermsFilterFieldItem1Context var1);

   void enterTermsFilterFieldItem(EsParser.TermsFilterFieldItemContext var1);

   void exitTermsFilterFieldItem(EsParser.TermsFilterFieldItemContext var1);

   void enterTermsFilterFieldValueString(EsParser.TermsFilterFieldValueStringContext var1);

   void exitTermsFilterFieldValueString(EsParser.TermsFilterFieldValueStringContext var1);

   void enterTermsFilterFieldValueArray(EsParser.TermsFilterFieldValueArrayContext var1);

   void exitTermsFilterFieldValueArray(EsParser.TermsFilterFieldValueArrayContext var1);

   void enterTermsFilterFieldValueLookup(EsParser.TermsFilterFieldValueLookupContext var1);

   void exitTermsFilterFieldValueLookup(EsParser.TermsFilterFieldValueLookupContext var1);

   void enterTermsFilterFieldNameArray(EsParser.TermsFilterFieldNameArrayContext var1);

   void exitTermsFilterFieldNameArray(EsParser.TermsFilterFieldNameArrayContext var1);

   void enterIndexExpr(EsParser.IndexExprContext var1);

   void exitIndexExpr(EsParser.IndexExprContext var1);

   void enterPathExpr(EsParser.PathExprContext var1);

   void exitPathExpr(EsParser.PathExprContext var1);

   void enterIdExpr(EsParser.IdExprContext var1);

   void exitIdExpr(EsParser.IdExprContext var1);

   void enterTermsetFilter(EsParser.TermsetFilterContext var1);

   void exitTermsetFilter(EsParser.TermsetFilterContext var1);

   void enterTermsetFilterItem(EsParser.TermsetFilterItemContext var1);

   void exitTermsetFilterItem(EsParser.TermsetFilterItemContext var1);

   void enterTermsetFilterTerms(EsParser.TermsetFilterTermsContext var1);

   void exitTermsetFilterTerms(EsParser.TermsetFilterTermsContext var1);

   void enterTermTypeFilter(EsParser.TermTypeFilterContext var1);

   void exitTermTypeFilter(EsParser.TermTypeFilterContext var1);

   void enterWildcardFilter(EsParser.WildcardFilterContext var1);

   void exitWildcardFilter(EsParser.WildcardFilterContext var1);

   void enterLeafGeoFilter(EsParser.LeafGeoFilterContext var1);

   void exitLeafGeoFilter(EsParser.LeafGeoFilterContext var1);

   void enterGeoBoundingBoxFilter(EsParser.GeoBoundingBoxFilterContext var1);

   void exitGeoBoundingBoxFilter(EsParser.GeoBoundingBoxFilterContext var1);

   void enterGeoBoundingBoxFilterField(EsParser.GeoBoundingBoxFilterFieldContext var1);

   void exitGeoBoundingBoxFilterField(EsParser.GeoBoundingBoxFilterFieldContext var1);

   void enterGeoDistanceFilter(EsParser.GeoDistanceFilterContext var1);

   void exitGeoDistanceFilter(EsParser.GeoDistanceFilterContext var1);

   void enterGeoDistanceFilterField(EsParser.GeoDistanceFilterFieldContext var1);

   void exitGeoDistanceFilterField(EsParser.GeoDistanceFilterFieldContext var1);

   void enterGeoPolygonFilter(EsParser.GeoPolygonFilterContext var1);

   void exitGeoPolygonFilter(EsParser.GeoPolygonFilterContext var1);

   void enterGeoPolygonFilterField(EsParser.GeoPolygonFilterFieldContext var1);

   void exitGeoPolygonFilterField(EsParser.GeoPolygonFilterFieldContext var1);

   void enterGeoShapeFilter(EsParser.GeoShapeFilterContext var1);

   void exitGeoShapeFilter(EsParser.GeoShapeFilterContext var1);

   void enterGeoShapeFilterField(EsParser.GeoShapeFilterFieldContext var1);

   void exitGeoShapeFilterField(EsParser.GeoShapeFilterFieldContext var1);

   void enterLeafShapeFilter(EsParser.LeafShapeFilterContext var1);

   void exitLeafShapeFilter(EsParser.LeafShapeFilterContext var1);

   void enterShapeFilter(EsParser.ShapeFilterContext var1);

   void exitShapeFilter(EsParser.ShapeFilterContext var1);

   void enterSpanQuery(EsParser.SpanQueryContext var1);

   void exitSpanQuery(EsParser.SpanQueryContext var1);

   void enterSpanFilter(EsParser.SpanFilterContext var1);

   void exitSpanFilter(EsParser.SpanFilterContext var1);

   void enterSpanNearFilter(EsParser.SpanNearFilterContext var1);

   void exitSpanNearFilter(EsParser.SpanNearFilterContext var1);

   void enterSpanNearFilterClausesPart(EsParser.SpanNearFilterClausesPartContext var1);

   void exitSpanNearFilterClausesPart(EsParser.SpanNearFilterClausesPartContext var1);

   void enterSpanNearFilterClausesPartItem(EsParser.SpanNearFilterClausesPartItemContext var1);

   void exitSpanNearFilterClausesPartItem(EsParser.SpanNearFilterClausesPartItemContext var1);

   void enterSpanNotFilter(EsParser.SpanNotFilterContext var1);

   void exitSpanNotFilter(EsParser.SpanNotFilterContext var1);

   void enterSpanNotFilterIncludePart(EsParser.SpanNotFilterIncludePartContext var1);

   void exitSpanNotFilterIncludePart(EsParser.SpanNotFilterIncludePartContext var1);

   void enterSpanNotFilterExcludePart(EsParser.SpanNotFilterExcludePartContext var1);

   void exitSpanNotFilterExcludePart(EsParser.SpanNotFilterExcludePartContext var1);

   void enterSpanOrFilter(EsParser.SpanOrFilterContext var1);

   void exitSpanOrFilter(EsParser.SpanOrFilterContext var1);

   void enterSpanOrFilterClausesPart(EsParser.SpanOrFilterClausesPartContext var1);

   void exitSpanOrFilterClausesPart(EsParser.SpanOrFilterClausesPartContext var1);

   void enterSpanTermFilter(EsParser.SpanTermFilterContext var1);

   void exitSpanTermFilter(EsParser.SpanTermFilterContext var1);

   void enterSpanWithinFilter(EsParser.SpanWithinFilterContext var1);

   void exitSpanWithinFilter(EsParser.SpanWithinFilterContext var1);

   void enterSpanWithinFilterPart(EsParser.SpanWithinFilterPartContext var1);

   void exitSpanWithinFilterPart(EsParser.SpanWithinFilterPartContext var1);

   void enterSpanContainingFilter(EsParser.SpanContainingFilterContext var1);

   void exitSpanContainingFilter(EsParser.SpanContainingFilterContext var1);

   void enterSpanContainingFilterPart(EsParser.SpanContainingFilterPartContext var1);

   void exitSpanContainingFilterPart(EsParser.SpanContainingFilterPartContext var1);

   void enterSpanFiledMaskingFilter(EsParser.SpanFiledMaskingFilterContext var1);

   void exitSpanFiledMaskingFilter(EsParser.SpanFiledMaskingFilterContext var1);

   void enterSpanFirstFilter(EsParser.SpanFirstFilterContext var1);

   void exitSpanFirstFilter(EsParser.SpanFirstFilterContext var1);

   void enterSpanFirstFilterPart(EsParser.SpanFirstFilterPartContext var1);

   void exitSpanFirstFilterPart(EsParser.SpanFirstFilterPartContext var1);

   void enterSpanMultiFilter(EsParser.SpanMultiFilterContext var1);

   void exitSpanMultiFilter(EsParser.SpanMultiFilterContext var1);

   void enterSpanMultiFilterPart(EsParser.SpanMultiFilterPartContext var1);

   void exitSpanMultiFilterPart(EsParser.SpanMultiFilterPartContext var1);

   void enterLeafOtherFilter(EsParser.LeafOtherFilterContext var1);

   void exitLeafOtherFilter(EsParser.LeafOtherFilterContext var1);

   void enterDistanceFeatureFilter(EsParser.DistanceFeatureFilterContext var1);

   void exitDistanceFeatureFilter(EsParser.DistanceFeatureFilterContext var1);

   void enterMoreLikeThisFilter(EsParser.MoreLikeThisFilterContext var1);

   void exitMoreLikeThisFilter(EsParser.MoreLikeThisFilterContext var1);

   void enterPercolateFilter(EsParser.PercolateFilterContext var1);

   void exitPercolateFilter(EsParser.PercolateFilterContext var1);

   void enterRankFeatureFilter(EsParser.RankFeatureFilterContext var1);

   void exitRankFeatureFilter(EsParser.RankFeatureFilterContext var1);

   void enterScriptFilter(EsParser.ScriptFilterContext var1);

   void exitScriptFilter(EsParser.ScriptFilterContext var1);

   void enterScriptFilterScriptSimple(EsParser.ScriptFilterScriptSimpleContext var1);

   void exitScriptFilterScriptSimple(EsParser.ScriptFilterScriptSimpleContext var1);

   void enterScriptFilterSourceValue(EsParser.ScriptFilterSourceValueContext var1);

   void exitScriptFilterSourceValue(EsParser.ScriptFilterSourceValueContext var1);

   void enterScriptScoreFilter(EsParser.ScriptScoreFilterContext var1);

   void exitScriptScoreFilter(EsParser.ScriptScoreFilterContext var1);

   void enterPinnedFilter(EsParser.PinnedFilterContext var1);

   void exitPinnedFilter(EsParser.PinnedFilterContext var1);

   void enterPinnedFilterOrganic(EsParser.PinnedFilterOrganicContext var1);

   void exitPinnedFilterOrganic(EsParser.PinnedFilterOrganicContext var1);

   void enterPinnedFilterDocs(EsParser.PinnedFilterDocsContext var1);

   void exitPinnedFilterDocs(EsParser.PinnedFilterDocsContext var1);

   void enterPinnedFilterDocsItem(EsParser.PinnedFilterDocsItemContext var1);

   void exitPinnedFilterDocsItem(EsParser.PinnedFilterDocsItemContext var1);

   void enterPinnedFilterIds(EsParser.PinnedFilterIdsContext var1);

   void exitPinnedFilterIds(EsParser.PinnedFilterIdsContext var1);

   void enterAggs(EsParser.AggsContext var1);

   void exitAggs(EsParser.AggsContext var1);

   void enterBucketAggs(EsParser.BucketAggsContext var1);

   void exitBucketAggs(EsParser.BucketAggsContext var1);

   void enterReindexStatement(EsParser.ReindexStatementContext var1);

   void exitReindexStatement(EsParser.ReindexStatementContext var1);

   void enterReindexStatementBody(EsParser.ReindexStatementBodyContext var1);

   void exitReindexStatementBody(EsParser.ReindexStatementBodyContext var1);

   void enterReindexStatementSection(EsParser.ReindexStatementSectionContext var1);

   void exitReindexStatementSection(EsParser.ReindexStatementSectionContext var1);

   void enterReindexStatementSectionIndex(EsParser.ReindexStatementSectionIndexContext var1);

   void exitReindexStatementSectionIndex(EsParser.ReindexStatementSectionIndexContext var1);

   void enterTermvectorsStatement(EsParser.TermvectorsStatementContext var1);

   void exitTermvectorsStatement(EsParser.TermvectorsStatementContext var1);

   void enterTermvectorsStaticStatement(EsParser.TermvectorsStaticStatementContext var1);

   void exitTermvectorsStaticStatement(EsParser.TermvectorsStaticStatementContext var1);

   void enterTermvectorsDynamicStatement(EsParser.TermvectorsDynamicStatementContext var1);

   void exitTermvectorsDynamicStatement(EsParser.TermvectorsDynamicStatementContext var1);

   void enterTermvectorsStatementBody(EsParser.TermvectorsStatementBodyContext var1);

   void exitTermvectorsStatementBody(EsParser.TermvectorsStatementBodyContext var1);

   void enterTermvectorsStatementBodyFields(EsParser.TermvectorsStatementBodyFieldsContext var1);

   void exitTermvectorsStatementBodyFields(EsParser.TermvectorsStatementBodyFieldsContext var1);

   void enterMtermvecotrsStatement(EsParser.MtermvecotrsStatementContext var1);

   void exitMtermvecotrsStatement(EsParser.MtermvecotrsStatementContext var1);

   void enterMtermvectorsStatementBody(EsParser.MtermvectorsStatementBodyContext var1);

   void exitMtermvectorsStatementBody(EsParser.MtermvectorsStatementBodyContext var1);

   void enterMtermvectorsStatementBodyItem(EsParser.MtermvectorsStatementBodyItemContext var1);

   void exitMtermvectorsStatementBodyItem(EsParser.MtermvectorsStatementBodyItemContext var1);

   void enterMtermvectorsStatementBodyFields(EsParser.MtermvectorsStatementBodyFieldsContext var1);

   void exitMtermvectorsStatementBodyFields(EsParser.MtermvectorsStatementBodyFieldsContext var1);

   void enterMtermvectorsStatementBodyIndex(EsParser.MtermvectorsStatementBodyIndexContext var1);

   void exitMtermvectorsStatementBodyIndex(EsParser.MtermvectorsStatementBodyIndexContext var1);

   void enterMtermvectorsStatementBodyId(EsParser.MtermvectorsStatementBodyIdContext var1);

   void exitMtermvectorsStatementBodyId(EsParser.MtermvectorsStatementBodyIdContext var1);

   void enterMtermvectorsStatementBody1(EsParser.MtermvectorsStatementBody1Context var1);

   void exitMtermvectorsStatementBody1(EsParser.MtermvectorsStatementBody1Context var1);

   void enterMtermvectorsStatementBody1Item(EsParser.MtermvectorsStatementBody1ItemContext var1);

   void exitMtermvectorsStatementBody1Item(EsParser.MtermvectorsStatementBody1ItemContext var1);

   void enterMtermvectorsStatementBody1Ids(EsParser.MtermvectorsStatementBody1IdsContext var1);

   void exitMtermvectorsStatementBody1Ids(EsParser.MtermvectorsStatementBody1IdsContext var1);

   void enterMtermvectorsStatementBody1Fields(EsParser.MtermvectorsStatementBody1FieldsContext var1);

   void exitMtermvectorsStatementBody1Fields(EsParser.MtermvectorsStatementBody1FieldsContext var1);

   void enterCreateEnrichStatement(EsParser.CreateEnrichStatementContext var1);

   void exitCreateEnrichStatement(EsParser.CreateEnrichStatementContext var1);

   void enterCreateEnrichStatementBody(EsParser.CreateEnrichStatementBodyContext var1);

   void exitCreateEnrichStatementBody(EsParser.CreateEnrichStatementBodyContext var1);

   void enterCreateEnrichStatementPolicyTypeIndices(EsParser.CreateEnrichStatementPolicyTypeIndicesContext var1);

   void exitCreateEnrichStatementPolicyTypeIndices(EsParser.CreateEnrichStatementPolicyTypeIndicesContext var1);

   void enterCreateEnrichStatementPolicyTypeMatchField(EsParser.CreateEnrichStatementPolicyTypeMatchFieldContext var1);

   void exitCreateEnrichStatementPolicyTypeMatchField(EsParser.CreateEnrichStatementPolicyTypeMatchFieldContext var1);

   void enterCreateEnrichStatementPolicyTypeEnrichFields(EsParser.CreateEnrichStatementPolicyTypeEnrichFieldsContext var1);

   void exitCreateEnrichStatementPolicyTypeEnrichFields(EsParser.CreateEnrichStatementPolicyTypeEnrichFieldsContext var1);

   void enterDeleteEnrichStatement(EsParser.DeleteEnrichStatementContext var1);

   void exitDeleteEnrichStatement(EsParser.DeleteEnrichStatementContext var1);

   void enterGetEnrichStatement(EsParser.GetEnrichStatementContext var1);

   void exitGetEnrichStatement(EsParser.GetEnrichStatementContext var1);

   void enterExecuteEnrichStatement(EsParser.ExecuteEnrichStatementContext var1);

   void exitExecuteEnrichStatement(EsParser.ExecuteEnrichStatementContext var1);

   void enterStatsEnrichStatement(EsParser.StatsEnrichStatementContext var1);

   void exitStatsEnrichStatement(EsParser.StatsEnrichStatementContext var1);

   void enterAutoScalingCreateOrUpdateStatement(EsParser.AutoScalingCreateOrUpdateStatementContext var1);

   void exitAutoScalingCreateOrUpdateStatement(EsParser.AutoScalingCreateOrUpdateStatementContext var1);

   void enterAutoScalingGetStatement(EsParser.AutoScalingGetStatementContext var1);

   void exitAutoScalingGetStatement(EsParser.AutoScalingGetStatementContext var1);

   void enterAutoScalingGetPolicyStatement(EsParser.AutoScalingGetPolicyStatementContext var1);

   void exitAutoScalingGetPolicyStatement(EsParser.AutoScalingGetPolicyStatementContext var1);

   void enterAutoScalingDeleteStatement(EsParser.AutoScalingDeleteStatementContext var1);

   void exitAutoScalingDeleteStatement(EsParser.AutoScalingDeleteStatementContext var1);

   void enterCatStatement(EsParser.CatStatementContext var1);

   void exitCatStatement(EsParser.CatStatementContext var1);

   void enterClusterStatement(EsParser.ClusterStatementContext var1);

   void exitClusterStatement(EsParser.ClusterStatementContext var1);

   void enterClusterClusterReplicationStatement(EsParser.ClusterClusterReplicationStatementContext var1);

   void exitClusterClusterReplicationStatement(EsParser.ClusterClusterReplicationStatementContext var1);

   void enterDataStreamStatement(EsParser.DataStreamStatementContext var1);

   void exitDataStreamStatement(EsParser.DataStreamStatementContext var1);

   void enterFeaturesStatement(EsParser.FeaturesStatementContext var1);

   void exitFeaturesStatement(EsParser.FeaturesStatementContext var1);

   void enterFleetStatement(EsParser.FleetStatementContext var1);

   void exitFleetStatement(EsParser.FleetStatementContext var1);

   void enterUriPrefixExpr(EsParser.UriPrefixExprContext var1);

   void exitUriPrefixExpr(EsParser.UriPrefixExprContext var1);

   void enterUriAppendixExpr(EsParser.UriAppendixExprContext var1);

   void exitUriAppendixExpr(EsParser.UriAppendixExprContext var1);

   void enterGraphStatement(EsParser.GraphStatementContext var1);

   void exitGraphStatement(EsParser.GraphStatementContext var1);

   void enterGraphStatementBody(EsParser.GraphStatementBodyContext var1);

   void exitGraphStatementBody(EsParser.GraphStatementBodyContext var1);

   void enterGraphStatementConnections(EsParser.GraphStatementConnectionsContext var1);

   void exitGraphStatementConnections(EsParser.GraphStatementConnectionsContext var1);

   void enterGraphStatementVertices(EsParser.GraphStatementVerticesContext var1);

   void exitGraphStatementVertices(EsParser.GraphStatementVerticesContext var1);

   void enterGraphStatementVertice(EsParser.GraphStatementVerticeContext var1);

   void exitGraphStatementVertice(EsParser.GraphStatementVerticeContext var1);

   void enterGraphStatementVerticeField(EsParser.GraphStatementVerticeFieldContext var1);

   void exitGraphStatementVerticeField(EsParser.GraphStatementVerticeFieldContext var1);

   void enterGraphStatementVerticeInclude(EsParser.GraphStatementVerticeIncludeContext var1);

   void exitGraphStatementVerticeInclude(EsParser.GraphStatementVerticeIncludeContext var1);

   void enterGraphStatementVerticeExclude(EsParser.GraphStatementVerticeExcludeContext var1);

   void exitGraphStatementVerticeExclude(EsParser.GraphStatementVerticeExcludeContext var1);

   void enterAdjacencyMatrixAgg(EsParser.AdjacencyMatrixAggContext var1);

   void exitAdjacencyMatrixAgg(EsParser.AdjacencyMatrixAggContext var1);

   void enterAdjacencyMatrixAggPart(EsParser.AdjacencyMatrixAggPartContext var1);

   void exitAdjacencyMatrixAggPart(EsParser.AdjacencyMatrixAggPartContext var1);

   void enterAutoDateHistogramAgg(EsParser.AutoDateHistogramAggContext var1);

   void exitAutoDateHistogramAgg(EsParser.AutoDateHistogramAggContext var1);

   void enterCategorizeTextAgg(EsParser.CategorizeTextAggContext var1);

   void exitCategorizeTextAgg(EsParser.CategorizeTextAggContext var1);

   void enterChildrenAgg(EsParser.ChildrenAggContext var1);

   void exitChildrenAgg(EsParser.ChildrenAggContext var1);

   void enterCompositeAgg(EsParser.CompositeAggContext var1);

   void exitCompositeAgg(EsParser.CompositeAggContext var1);

   void enterCompositeAggItem(EsParser.CompositeAggItemContext var1);

   void exitCompositeAggItem(EsParser.CompositeAggItemContext var1);

   void enterDateHistogramAgg(EsParser.DateHistogramAggContext var1);

   void exitDateHistogramAgg(EsParser.DateHistogramAggContext var1);

   void enterDateRangeAgg(EsParser.DateRangeAggContext var1);

   void exitDateRangeAgg(EsParser.DateRangeAggContext var1);

   void enterDiversifiedSamplerAgg(EsParser.DiversifiedSamplerAggContext var1);

   void exitDiversifiedSamplerAgg(EsParser.DiversifiedSamplerAggContext var1);

   void enterFilterAgg(EsParser.FilterAggContext var1);

   void exitFilterAgg(EsParser.FilterAggContext var1);

   void enterFiltersAgg(EsParser.FiltersAggContext var1);

   void exitFiltersAgg(EsParser.FiltersAggContext var1);

   void enterFiltersAggBody(EsParser.FiltersAggBodyContext var1);

   void exitFiltersAggBody(EsParser.FiltersAggBodyContext var1);

   void enterFiltersAggBodyN(EsParser.FiltersAggBodyNContext var1);

   void exitFiltersAggBodyN(EsParser.FiltersAggBodyNContext var1);

   void enterFiltersAggBodyNItem(EsParser.FiltersAggBodyNItemContext var1);

   void exitFiltersAggBodyNItem(EsParser.FiltersAggBodyNItemContext var1);

   void enterGeoDistanceAgg(EsParser.GeoDistanceAggContext var1);

   void exitGeoDistanceAgg(EsParser.GeoDistanceAggContext var1);

   void enterGeoHashGridAgg(EsParser.GeoHashGridAggContext var1);

   void exitGeoHashGridAgg(EsParser.GeoHashGridAggContext var1);

   void enterGeoTileGridAgg(EsParser.GeoTileGridAggContext var1);

   void exitGeoTileGridAgg(EsParser.GeoTileGridAggContext var1);

   void enterHistogramAgg(EsParser.HistogramAggContext var1);

   void exitHistogramAgg(EsParser.HistogramAggContext var1);

   void enterIpRangeAgg(EsParser.IpRangeAggContext var1);

   void exitIpRangeAgg(EsParser.IpRangeAggContext var1);

   void enterMissingAgg(EsParser.MissingAggContext var1);

   void exitMissingAgg(EsParser.MissingAggContext var1);

   void enterMultiTermsAgg(EsParser.MultiTermsAggContext var1);

   void exitMultiTermsAgg(EsParser.MultiTermsAggContext var1);

   void enterNestedAgg(EsParser.NestedAggContext var1);

   void exitNestedAgg(EsParser.NestedAggContext var1);

   void enterParentAgg(EsParser.ParentAggContext var1);

   void exitParentAgg(EsParser.ParentAggContext var1);

   void enterRangeAgg(EsParser.RangeAggContext var1);

   void exitRangeAgg(EsParser.RangeAggContext var1);

   void enterRangeAggItem(EsParser.RangeAggItemContext var1);

   void exitRangeAggItem(EsParser.RangeAggItemContext var1);

   void enterRareTermsAgg(EsParser.RareTermsAggContext var1);

   void exitRareTermsAgg(EsParser.RareTermsAggContext var1);

   void enterReverseNestedAgg(EsParser.ReverseNestedAggContext var1);

   void exitReverseNestedAgg(EsParser.ReverseNestedAggContext var1);

   void enterSamplerAgg(EsParser.SamplerAggContext var1);

   void exitSamplerAgg(EsParser.SamplerAggContext var1);

   void enterSignificantCrimeTypesAgg(EsParser.SignificantCrimeTypesAggContext var1);

   void exitSignificantCrimeTypesAgg(EsParser.SignificantCrimeTypesAggContext var1);

   void enterSignificantTextAgg(EsParser.SignificantTextAggContext var1);

   void exitSignificantTextAgg(EsParser.SignificantTextAggContext var1);

   void enterSignificantTermsAgg(EsParser.SignificantTermsAggContext var1);

   void exitSignificantTermsAgg(EsParser.SignificantTermsAggContext var1);

   void enterAggBackgroundFilter(EsParser.AggBackgroundFilterContext var1);

   void exitAggBackgroundFilter(EsParser.AggBackgroundFilterContext var1);

   void enterTermsAgg(EsParser.TermsAggContext var1);

   void exitTermsAgg(EsParser.TermsAggContext var1);

   void enterVariableWidthHistogramAgg(EsParser.VariableWidthHistogramAggContext var1);

   void exitVariableWidthHistogramAgg(EsParser.VariableWidthHistogramAggContext var1);

   void enterMetricsAggs(EsParser.MetricsAggsContext var1);

   void exitMetricsAggs(EsParser.MetricsAggsContext var1);

   void enterAvgAggs(EsParser.AvgAggsContext var1);

   void exitAvgAggs(EsParser.AvgAggsContext var1);

   void enterBoxplotAggs(EsParser.BoxplotAggsContext var1);

   void exitBoxplotAggs(EsParser.BoxplotAggsContext var1);

   void enterCardinalityAggs(EsParser.CardinalityAggsContext var1);

   void exitCardinalityAggs(EsParser.CardinalityAggsContext var1);

   void enterExtendedStatsAggs(EsParser.ExtendedStatsAggsContext var1);

   void exitExtendedStatsAggs(EsParser.ExtendedStatsAggsContext var1);

   void enterGeoBoundsAggs(EsParser.GeoBoundsAggsContext var1);

   void exitGeoBoundsAggs(EsParser.GeoBoundsAggsContext var1);

   void enterGeoCentroidAggs(EsParser.GeoCentroidAggsContext var1);

   void exitGeoCentroidAggs(EsParser.GeoCentroidAggsContext var1);

   void enterGeoLineAggs(EsParser.GeoLineAggsContext var1);

   void exitGeoLineAggs(EsParser.GeoLineAggsContext var1);

   void enterMatrixStatsAggs(EsParser.MatrixStatsAggsContext var1);

   void exitMatrixStatsAggs(EsParser.MatrixStatsAggsContext var1);

   void enterMatrixStatsAggsPart(EsParser.MatrixStatsAggsPartContext var1);

   void exitMatrixStatsAggsPart(EsParser.MatrixStatsAggsPartContext var1);

   void enterMaxAggs(EsParser.MaxAggsContext var1);

   void exitMaxAggs(EsParser.MaxAggsContext var1);

   void enterMedianAbsoluteDeviationAggs(EsParser.MedianAbsoluteDeviationAggsContext var1);

   void exitMedianAbsoluteDeviationAggs(EsParser.MedianAbsoluteDeviationAggsContext var1);

   void enterMinAggs(EsParser.MinAggsContext var1);

   void exitMinAggs(EsParser.MinAggsContext var1);

   void enterPercentileRanksAggs(EsParser.PercentileRanksAggsContext var1);

   void exitPercentileRanksAggs(EsParser.PercentileRanksAggsContext var1);

   void enterPercentilesAggs(EsParser.PercentilesAggsContext var1);

   void exitPercentilesAggs(EsParser.PercentilesAggsContext var1);

   void enterRateAggs(EsParser.RateAggsContext var1);

   void exitRateAggs(EsParser.RateAggsContext var1);

   void enterRateAggsItem(EsParser.RateAggsItemContext var1);

   void exitRateAggsItem(EsParser.RateAggsItemContext var1);

   void enterScriptedMetricAggs(EsParser.ScriptedMetricAggsContext var1);

   void exitScriptedMetricAggs(EsParser.ScriptedMetricAggsContext var1);

   void enterStatsAggs(EsParser.StatsAggsContext var1);

   void exitStatsAggs(EsParser.StatsAggsContext var1);

   void enterStringStatsAggs(EsParser.StringStatsAggsContext var1);

   void exitStringStatsAggs(EsParser.StringStatsAggsContext var1);

   void enterSumAggs(EsParser.SumAggsContext var1);

   void exitSumAggs(EsParser.SumAggsContext var1);

   void enterTTestAggs(EsParser.TTestAggsContext var1);

   void exitTTestAggs(EsParser.TTestAggsContext var1);

   void enterTTestAggsItem(EsParser.TTestAggsItemContext var1);

   void exitTTestAggsItem(EsParser.TTestAggsItemContext var1);

   void enterTopHitsAggs(EsParser.TopHitsAggsContext var1);

   void exitTopHitsAggs(EsParser.TopHitsAggsContext var1);

   void enterTopMetricsAggs(EsParser.TopMetricsAggsContext var1);

   void exitTopMetricsAggs(EsParser.TopMetricsAggsContext var1);

   void enterTopMetricsAggsItem(EsParser.TopMetricsAggsItemContext var1);

   void exitTopMetricsAggsItem(EsParser.TopMetricsAggsItemContext var1);

   void enterTopMetricsAggSort(EsParser.TopMetricsAggSortContext var1);

   void exitTopMetricsAggSort(EsParser.TopMetricsAggSortContext var1);

   void enterTopMetricsAggsMetrics(EsParser.TopMetricsAggsMetricsContext var1);

   void exitTopMetricsAggsMetrics(EsParser.TopMetricsAggsMetricsContext var1);

   void enterTopMetricsAggsMetricsItems(EsParser.TopMetricsAggsMetricsItemsContext var1);

   void exitTopMetricsAggsMetricsItems(EsParser.TopMetricsAggsMetricsItemsContext var1);

   void enterTopMetricsAggsMetricsItem(EsParser.TopMetricsAggsMetricsItemContext var1);

   void exitTopMetricsAggsMetricsItem(EsParser.TopMetricsAggsMetricsItemContext var1);

   void enterTypesCountAggs(EsParser.TypesCountAggsContext var1);

   void exitTypesCountAggs(EsParser.TypesCountAggsContext var1);

   void enterWeightedAvgAggs(EsParser.WeightedAvgAggsContext var1);

   void exitWeightedAvgAggs(EsParser.WeightedAvgAggsContext var1);

   void enterWeightedAvgAggsItem(EsParser.WeightedAvgAggsItemContext var1);

   void exitWeightedAvgAggsItem(EsParser.WeightedAvgAggsItemContext var1);

   void enterWeightedAvgAggsItemValue(EsParser.WeightedAvgAggsItemValueContext var1);

   void exitWeightedAvgAggsItemValue(EsParser.WeightedAvgAggsItemValueContext var1);

   void enterWeightedAvgAggsItemWeight(EsParser.WeightedAvgAggsItemWeightContext var1);

   void exitWeightedAvgAggsItemWeight(EsParser.WeightedAvgAggsItemWeightContext var1);

   void enterValueCountAggs(EsParser.ValueCountAggsContext var1);

   void exitValueCountAggs(EsParser.ValueCountAggsContext var1);

   void enterPipeLineAggs(EsParser.PipeLineAggsContext var1);

   void exitPipeLineAggs(EsParser.PipeLineAggsContext var1);

   void enterAverageBucketAggs(EsParser.AverageBucketAggsContext var1);

   void exitAverageBucketAggs(EsParser.AverageBucketAggsContext var1);

   void enterBucketScriptAggs(EsParser.BucketScriptAggsContext var1);

   void exitBucketScriptAggs(EsParser.BucketScriptAggsContext var1);

   void enterBucketCountKsTestAggs(EsParser.BucketCountKsTestAggsContext var1);

   void exitBucketCountKsTestAggs(EsParser.BucketCountKsTestAggsContext var1);

   void enterBucketCorreationAggs(EsParser.BucketCorreationAggsContext var1);

   void exitBucketCorreationAggs(EsParser.BucketCorreationAggsContext var1);

   void enterBucketSelectorAggs(EsParser.BucketSelectorAggsContext var1);

   void exitBucketSelectorAggs(EsParser.BucketSelectorAggsContext var1);

   void enterBucketSortAggs(EsParser.BucketSortAggsContext var1);

   void exitBucketSortAggs(EsParser.BucketSortAggsContext var1);

   void enterCumulativeCardinalityAggs(EsParser.CumulativeCardinalityAggsContext var1);

   void exitCumulativeCardinalityAggs(EsParser.CumulativeCardinalityAggsContext var1);

   void enterCumulativeSumAggs(EsParser.CumulativeSumAggsContext var1);

   void exitCumulativeSumAggs(EsParser.CumulativeSumAggsContext var1);

   void enterDerivativeAggs(EsParser.DerivativeAggsContext var1);

   void exitDerivativeAggs(EsParser.DerivativeAggsContext var1);

   void enterExtendedStatsBucketAggs(EsParser.ExtendedStatsBucketAggsContext var1);

   void exitExtendedStatsBucketAggs(EsParser.ExtendedStatsBucketAggsContext var1);

   void enterMaxBucketAggs(EsParser.MaxBucketAggsContext var1);

   void exitMaxBucketAggs(EsParser.MaxBucketAggsContext var1);

   void enterMinBucketAggs(EsParser.MinBucketAggsContext var1);

   void exitMinBucketAggs(EsParser.MinBucketAggsContext var1);

   void enterMovingAvgAggs(EsParser.MovingAvgAggsContext var1);

   void exitMovingAvgAggs(EsParser.MovingAvgAggsContext var1);

   void enterMovingFnAggs(EsParser.MovingFnAggsContext var1);

   void exitMovingFnAggs(EsParser.MovingFnAggsContext var1);

   void enterMovingPercentilesAggs(EsParser.MovingPercentilesAggsContext var1);

   void exitMovingPercentilesAggs(EsParser.MovingPercentilesAggsContext var1);

   void enterNormalizeAggs(EsParser.NormalizeAggsContext var1);

   void exitNormalizeAggs(EsParser.NormalizeAggsContext var1);

   void enterPercentilesBucketAggs(EsParser.PercentilesBucketAggsContext var1);

   void exitPercentilesBucketAggs(EsParser.PercentilesBucketAggsContext var1);

   void enterSerialDiffAggs(EsParser.SerialDiffAggsContext var1);

   void exitSerialDiffAggs(EsParser.SerialDiffAggsContext var1);

   void enterStatsBucketAggs(EsParser.StatsBucketAggsContext var1);

   void exitStatsBucketAggs(EsParser.StatsBucketAggsContext var1);

   void enterSumBucketAggs(EsParser.SumBucketAggsContext var1);

   void exitSumBucketAggs(EsParser.SumBucketAggsContext var1);

   void enterInferenceAggs(EsParser.InferenceAggsContext var1);

   void exitInferenceAggs(EsParser.InferenceAggsContext var1);

   void enterAggCommonPart(EsParser.AggCommonPartContext var1);

   void exitAggCommonPart(EsParser.AggCommonPartContext var1);

   void enterFieldFilter(EsParser.FieldFilterContext var1);

   void exitFieldFilter(EsParser.FieldFilterContext var1);

   void enterFieldSimpleFilter(EsParser.FieldSimpleFilterContext var1);

   void exitFieldSimpleFilter(EsParser.FieldSimpleFilterContext var1);

   void enterFieldExactFilter(EsParser.FieldExactFilterContext var1);

   void exitFieldExactFilter(EsParser.FieldExactFilterContext var1);

   void enterFieldQueryFilter(EsParser.FieldQueryFilterContext var1);

   void exitFieldQueryFilter(EsParser.FieldQueryFilterContext var1);

   void enterFieldValueFilter(EsParser.FieldValueFilterContext var1);

   void exitFieldValueFilter(EsParser.FieldValueFilterContext var1);

   void enterFilterQueryFieldValue(EsParser.FilterQueryFieldValueContext var1);

   void exitFilterQueryFieldValue(EsParser.FilterQueryFieldValueContext var1);

   void enterFieldsNamesExpr(EsParser.FieldsNamesExprContext var1);

   void exitFieldsNamesExpr(EsParser.FieldsNamesExprContext var1);

   void enterFieldValueExpr(EsParser.FieldValueExprContext var1);

   void exitFieldValueExpr(EsParser.FieldValueExprContext var1);

   void enterFieldValueExpr1(EsParser.FieldValueExpr1Context var1);

   void exitFieldValueExpr1(EsParser.FieldValueExpr1Context var1);

   void enterQueryExpr(EsParser.QueryExprContext var1);

   void exitQueryExpr(EsParser.QueryExprContext var1);

   void enterValueExpr(EsParser.ValueExprContext var1);

   void exitValueExpr(EsParser.ValueExprContext var1);

   void enterFieldNameExpr(EsParser.FieldNameExprContext var1);

   void exitFieldNameExpr(EsParser.FieldNameExprContext var1);

   void enterOperatorExpr(EsParser.OperatorExprContext var1);

   void exitOperatorExpr(EsParser.OperatorExprContext var1);

   void enterDefaultExpr(EsParser.DefaultExprContext var1);

   void exitDefaultExpr(EsParser.DefaultExprContext var1);

   void enterSourceFieldsExpr(EsParser.SourceFieldsExprContext var1);

   void exitSourceFieldsExpr(EsParser.SourceFieldsExprContext var1);

   void enterSortExpr(EsParser.SortExprContext var1);

   void exitSortExpr(EsParser.SortExprContext var1);

   void enterSortItems(EsParser.SortItemsContext var1);

   void exitSortItems(EsParser.SortItemsContext var1);

   void enterSortItem(EsParser.SortItemContext var1);

   void exitSortItem(EsParser.SortItemContext var1);

   void enterSortExprOptions(EsParser.SortExprOptionsContext var1);

   void exitSortExprOptions(EsParser.SortExprOptionsContext var1);

   void enterScriptExpr(EsParser.ScriptExprContext var1);

   void exitScriptExpr(EsParser.ScriptExprContext var1);

   void enterFieldLikeExpr(EsParser.FieldLikeExprContext var1);

   void exitFieldLikeExpr(EsParser.FieldLikeExprContext var1);

   void enterFieldLikeExprN(EsParser.FieldLikeExprNContext var1);

   void exitFieldLikeExprN(EsParser.FieldLikeExprNContext var1);

   void enterFieldLikeExpr1(EsParser.FieldLikeExpr1Context var1);

   void exitFieldLikeExpr1(EsParser.FieldLikeExpr1Context var1);

   void enterFieldLikeExprValue(EsParser.FieldLikeExprValueContext var1);

   void exitFieldLikeExprValue(EsParser.FieldLikeExprValueContext var1);

   void enterFieldLikeExprValueObj(EsParser.FieldLikeExprValueObjContext var1);

   void exitFieldLikeExprValueObj(EsParser.FieldLikeExprValueObjContext var1);

   void enterFieldLikeExprValueSimple(EsParser.FieldLikeExprValueSimpleContext var1);

   void exitFieldLikeExprValueSimple(EsParser.FieldLikeExprValueSimpleContext var1);

   void enterFieldDocuments(EsParser.FieldDocumentsContext var1);

   void exitFieldDocuments(EsParser.FieldDocumentsContext var1);

   void enterFieldDocument(EsParser.FieldDocumentContext var1);

   void exitFieldDocument(EsParser.FieldDocumentContext var1);

   void enterFieldDocumentValue(EsParser.FieldDocumentValueContext var1);

   void exitFieldDocumentValue(EsParser.FieldDocumentValueContext var1);

   void enterFieldIndex1(EsParser.FieldIndex1Context var1);

   void exitFieldIndex1(EsParser.FieldIndex1Context var1);

   void enterFieldId1(EsParser.FieldId1Context var1);

   void exitFieldId1(EsParser.FieldId1Context var1);

   void enterFieldIndex(EsParser.FieldIndexContext var1);

   void exitFieldIndex(EsParser.FieldIndexContext var1);

   void enterFieldId(EsParser.FieldIdContext var1);

   void exitFieldId(EsParser.FieldIdContext var1);

   void enterPairs(EsParser.PairsContext var1);

   void exitPairs(EsParser.PairsContext var1);

   void enterUriSeg(EsParser.UriSegContext var1);

   void exitUriSeg(EsParser.UriSegContext var1);

   void enterUriSegIndex(EsParser.UriSegIndexContext var1);

   void exitUriSegIndex(EsParser.UriSegIndexContext var1);

   void enterUriIndexAtom(EsParser.UriIndexAtomContext var1);

   void exitUriIndexAtom(EsParser.UriIndexAtomContext var1);

   void enterString(EsParser.StringContext var1);

   void exitString(EsParser.StringContext var1);

   void enterMappingString(EsParser.MappingStringContext var1);

   void exitMappingString(EsParser.MappingStringContext var1);

   void enterObj(EsParser.ObjContext var1);

   void exitObj(EsParser.ObjContext var1);

   void enterPair(EsParser.PairContext var1);

   void exitPair(EsParser.PairContext var1);

   void enterStringArr(EsParser.StringArrContext var1);

   void exitStringArr(EsParser.StringArrContext var1);

   void enterArr(EsParser.ArrContext var1);

   void exitArr(EsParser.ArrContext var1);

   void enterBool(EsParser.BoolContext var1);

   void exitBool(EsParser.BoolContext var1);

   void enterJvalue(EsParser.JvalueContext var1);

   void exitJvalue(EsParser.JvalueContext var1);

   void enterUriFragments(EsParser.UriFragmentsContext var1);

   void exitUriFragments(EsParser.UriFragmentsContext var1);

   void enterUriFragmentSegments(EsParser.UriFragmentSegmentsContext var1);

   void exitUriFragmentSegments(EsParser.UriFragmentSegmentsContext var1);

   void enterUriFragmentSegment(EsParser.UriFragmentSegmentContext var1);

   void exitUriFragmentSegment(EsParser.UriFragmentSegmentContext var1);

   void enterMappingResponse(EsParser.MappingResponseContext var1);

   void exitMappingResponse(EsParser.MappingResponseContext var1);

   void enterMappingResponseMapping(EsParser.MappingResponseMappingContext var1);

   void exitMappingResponseMapping(EsParser.MappingResponseMappingContext var1);

   void enterSearchResponse(EsParser.SearchResponseContext var1);

   void exitSearchResponse(EsParser.SearchResponseContext var1);

   void enterSearchResponseItem(EsParser.SearchResponseItemContext var1);

   void exitSearchResponseItem(EsParser.SearchResponseItemContext var1);

   void enterSearchResponseItemHits(EsParser.SearchResponseItemHitsContext var1);

   void exitSearchResponseItemHits(EsParser.SearchResponseItemHitsContext var1);

   void enterSearchResponseItemAgregations(EsParser.SearchResponseItemAgregationsContext var1);

   void exitSearchResponseItemAgregations(EsParser.SearchResponseItemAgregationsContext var1);

   void enterSearchResponseHitsHits(EsParser.SearchResponseHitsHitsContext var1);

   void exitSearchResponseHitsHits(EsParser.SearchResponseHitsHitsContext var1);

   void enterSearchResponseHitsHitsMemo(EsParser.SearchResponseHitsHitsMemoContext var1);

   void exitSearchResponseHitsHitsMemo(EsParser.SearchResponseHitsHitsMemoContext var1);

   void enterSearchResponseHitsHitsIndex(EsParser.SearchResponseHitsHitsIndexContext var1);

   void exitSearchResponseHitsHitsIndex(EsParser.SearchResponseHitsHitsIndexContext var1);

   void enterSearchResponseHitsHitsType(EsParser.SearchResponseHitsHitsTypeContext var1);

   void exitSearchResponseHitsHitsType(EsParser.SearchResponseHitsHitsTypeContext var1);

   void enterSearchResponseHitsHitsSource(EsParser.SearchResponseHitsHitsSourceContext var1);

   void exitSearchResponseHitsHitsSource(EsParser.SearchResponseHitsHitsSourceContext var1);

   void enterSearchResponseHitsHitsId(EsParser.SearchResponseHitsHitsIdContext var1);

   void exitSearchResponseHitsHitsId(EsParser.SearchResponseHitsHitsIdContext var1);

   void enterSearchResponseHitsHitsFields(EsParser.SearchResponseHitsHitsFieldsContext var1);

   void exitSearchResponseHitsHitsFields(EsParser.SearchResponseHitsHitsFieldsContext var1);

   void enterGetResponse(EsParser.GetResponseContext var1);

   void exitGetResponse(EsParser.GetResponseContext var1);
}
