export function HiveSql(input: any): this;
export class HiveSql {
    constructor(input: any);
    _interp: any;
    ruleNames: string[];
    literalNames: string[];
    symbolicNames: string[];
    _input: any;
    constructor: typeof HiveSql;
    get atn(): any;
    program(): ProgramContext;
    state: number;
    block(): BlockContext;
    begin_end_block(): Begin_end_blockContext;
    single_block_stmt(): Single_block_stmtContext;
    block_end(): Block_endContext;
    proc_block(): Proc_blockContext;
    stmt(): StmtContext;
    semicolon_stmt(): Semicolon_stmtContext;
    exception_block(): Exception_blockContext;
    exception_block_item(): Exception_block_itemContext;
    null_stmt(): Null_stmtContext;
    expr_stmt(): Expr_stmtContext;
    assignment_stmt(): Assignment_stmtContext;
    assignment_stmt_item(): Assignment_stmt_itemContext;
    assignment_stmt_single_item(): Assignment_stmt_single_itemContext;
    assignment_stmt_multiple_item(): Assignment_stmt_multiple_itemContext;
    assignment_stmt_select_item(): Assignment_stmt_select_itemContext;
    allocate_cursor_stmt(): Allocate_cursor_stmtContext;
    associate_locator_stmt(): Associate_locator_stmtContext;
    begin_transaction_stmt(): Begin_transaction_stmtContext;
    break_stmt(): Break_stmtContext;
    call_stmt(): Call_stmtContext;
    declare_stmt(): Declare_stmtContext;
    declare_block(): Declare_blockContext;
    declare_block_inplace(): Declare_block_inplaceContext;
    declare_stmt_item(): Declare_stmt_itemContext;
    declare_var_item(): Declare_var_itemContext;
    declare_condition_item(): Declare_condition_itemContext;
    declare_cursor_item(): Declare_cursor_itemContext;
    cursor_with_return(): Cursor_with_returnContext;
    cursor_without_return(): Cursor_without_returnContext;
    declare_handler_item(): Declare_handler_itemContext;
    declare_temporary_table_item(): Declare_temporary_table_itemContext;
    create_table_stmt(): Create_table_stmtContext;
    create_local_temp_table_stmt(): Create_local_temp_table_stmtContext;
    create_table_definition(): Create_table_definitionContext;
    create_table_columns(): Create_table_columnsContext;
    create_table_columns_item(): Create_table_columns_itemContext;
    column_name(): Column_nameContext;
    create_table_column_inline_cons(): Create_table_column_inline_consContext;
    create_table_column_cons(): Create_table_column_consContext;
    create_table_fk_action(): Create_table_fk_actionContext;
    create_table_preoptions(): Create_table_preoptionsContext;
    create_table_preoptions_item(): Create_table_preoptions_itemContext;
    create_table_preoptions_td_item(): Create_table_preoptions_td_itemContext;
    create_table_options(): Create_table_optionsContext;
    create_table_options_item(): Create_table_options_itemContext;
    create_table_options_ora_item(): Create_table_options_ora_itemContext;
    create_table_options_db2_item(): Create_table_options_db2_itemContext;
    create_table_options_td_item(): Create_table_options_td_itemContext;
    create_table_options_hive_item(): Create_table_options_hive_itemContext;
    create_table_hive_row_format(): Create_table_hive_row_formatContext;
    create_table_hive_row_format_fields(): Create_table_hive_row_format_fieldsContext;
    create_table_options_mssql_item(): Create_table_options_mssql_itemContext;
    create_table_options_mysql_item(): Create_table_options_mysql_itemContext;
    alter_table_stmt(): Alter_table_stmtContext;
    alter_table_item(): Alter_table_itemContext;
    alter_table_add_constraint(): Alter_table_add_constraintContext;
    alter_table_add_constraint_item(): Alter_table_add_constraint_itemContext;
    dtype(): DtypeContext;
    dtype_len(): Dtype_lenContext;
    dtype_attr(): Dtype_attrContext;
    dtype_default(): Dtype_defaultContext;
    create_database_stmt(): Create_database_stmtContext;
    create_database_option(): Create_database_optionContext;
    create_function_stmt(): Create_function_stmtContext;
    create_function_return(): Create_function_returnContext;
    create_package_stmt(): Create_package_stmtContext;
    package_spec(): Package_specContext;
    package_spec_item(): Package_spec_itemContext;
    create_package_body_stmt(): Create_package_body_stmtContext;
    package_body(): Package_bodyContext;
    package_body_item(): Package_body_itemContext;
    create_procedure_stmt(): Create_procedure_stmtContext;
    create_routine_params(): Create_routine_paramsContext;
    create_routine_param_item(): Create_routine_param_itemContext;
    create_routine_options(): Create_routine_optionsContext;
    create_routine_option(): Create_routine_optionContext;
    drop_stmt(): Drop_stmtContext;
    end_transaction_stmt(): End_transaction_stmtContext;
    exec_stmt(): Exec_stmtContext;
    if_stmt(): If_stmtContext;
    if_plsql_stmt(): If_plsql_stmtContext;
    if_tsql_stmt(): If_tsql_stmtContext;
    if_bteq_stmt(): If_bteq_stmtContext;
    elseif_block(): Elseif_blockContext;
    else_block(): Else_blockContext;
    include_stmt(): Include_stmtContext;
    insert_stmt(): Insert_stmtContext;
    insert_stmt_cols(): Insert_stmt_colsContext;
    insert_stmt_rows(): Insert_stmt_rowsContext;
    insert_stmt_row(): Insert_stmt_rowContext;
    insert_directory_stmt(): Insert_directory_stmtContext;
    exit_stmt(): Exit_stmtContext;
    get_diag_stmt(): Get_diag_stmtContext;
    get_diag_stmt_item(): Get_diag_stmt_itemContext;
    get_diag_stmt_exception_item(): Get_diag_stmt_exception_itemContext;
    get_diag_stmt_rowcount_item(): Get_diag_stmt_rowcount_itemContext;
    grant_stmt(): Grant_stmtContext;
    grant_stmt_item(): Grant_stmt_itemContext;
    leave_stmt(): Leave_stmtContext;
    map_object_stmt(): Map_object_stmtContext;
    open_stmt(): Open_stmtContext;
    fetch_stmt(): Fetch_stmtContext;
    collect_stats_stmt(): Collect_stats_stmtContext;
    collect_stats_clause(): Collect_stats_clauseContext;
    close_stmt(): Close_stmtContext;
    cmp_stmt(): Cmp_stmtContext;
    cmp_source(): Cmp_sourceContext;
    copy_from_local_stmt(): Copy_from_local_stmtContext;
    copy_stmt(): Copy_stmtContext;
    copy_source(): Copy_sourceContext;
    copy_target(): Copy_targetContext;
    copy_option(): Copy_optionContext;
    copy_file_option(): Copy_file_optionContext;
    commit_stmt(): Commit_stmtContext;
    create_index_stmt(): Create_index_stmtContext;
    create_index_col(): Create_index_colContext;
    index_storage_clause(): Index_storage_clauseContext;
    index_mssql_storage_clause(): Index_mssql_storage_clauseContext;
    print_stmt(): Print_stmtContext;
    quit_stmt(): Quit_stmtContext;
    raise_stmt(): Raise_stmtContext;
    resignal_stmt(): Resignal_stmtContext;
    return_stmt(): Return_stmtContext;
    rollback_stmt(): Rollback_stmtContext;
    set_session_option(): Set_session_optionContext;
    set_current_schema_option(): Set_current_schema_optionContext;
    set_mssql_session_option(): Set_mssql_session_optionContext;
    set_teradata_session_option(): Set_teradata_session_optionContext;
    signal_stmt(): Signal_stmtContext;
    summary_stmt(): Summary_stmtContext;
    truncate_stmt(): Truncate_stmtContext;
    use_stmt(): Use_stmtContext;
    values_into_stmt(): Values_into_stmtContext;
    while_stmt(): While_stmtContext;
    for_cursor_stmt(): For_cursor_stmtContext;
    for_range_stmt(): For_range_stmtContext;
    label(): LabelContext;
    using_clause(): Using_clauseContext;
    select_stmt(): Select_stmtContext;
    cte_select_stmt(): Cte_select_stmtContext;
    cte_select_stmt_item(): Cte_select_stmt_itemContext;
    cte_select_cols(): Cte_select_colsContext;
    fullselect_stmt(): Fullselect_stmtContext;
    fullselect_stmt_item(): Fullselect_stmt_itemContext;
    fullselect_set_clause(): Fullselect_set_clauseContext;
    subselect_stmt(): Subselect_stmtContext;
    select_list(): Select_listContext;
    select_list_set(): Select_list_setContext;
    select_list_limit(): Select_list_limitContext;
    select_list_item(): Select_list_itemContext;
    select_list_alias(): Select_list_aliasContext;
    select_list_asterisk(): Select_list_asteriskContext;
    into_clause(): Into_clauseContext;
    from_clause(): From_clauseContext;
    from_table_clause(): From_table_clauseContext;
    from_table_name_clause(): From_table_name_clauseContext;
    from_subselect_clause(): From_subselect_clauseContext;
    from_join_clause(): From_join_clauseContext;
    from_join_type_clause(): From_join_type_clauseContext;
    from_table_values_clause(): From_table_values_clauseContext;
    from_table_values_row(): From_table_values_rowContext;
    from_alias_clause(): From_alias_clauseContext;
    table_name(): Table_nameContext;
    where_clause(): Where_clauseContext;
    group_by_clause(): Group_by_clauseContext;
    having_clause(): Having_clauseContext;
    qualify_clause(): Qualify_clauseContext;
    order_by_clause(): Order_by_clauseContext;
    select_options(): Select_optionsContext;
    select_options_item(): Select_options_itemContext;
    update_stmt(): Update_stmtContext;
    update_assignment(): Update_assignmentContext;
    update_table(): Update_tableContext;
    update_upsert(): Update_upsertContext;
    merge_stmt(): Merge_stmtContext;
    merge_table(): Merge_tableContext;
    merge_condition(): Merge_conditionContext;
    merge_action(): Merge_actionContext;
    delete_stmt(): Delete_stmtContext;
    delete_alias(): Delete_aliasContext;
    describe_stmt(): Describe_stmtContext;
    bool_expr(_p: any): Bool_exprContext;
    bool_expr_atom(): Bool_expr_atomContext;
    bool_expr_unary(): Bool_expr_unaryContext;
    bool_expr_single_in(): Bool_expr_single_inContext;
    bool_expr_multi_in(): Bool_expr_multi_inContext;
    bool_expr_binary(): Bool_expr_binaryContext;
    bool_expr_logical_operator(): Bool_expr_logical_operatorContext;
    bool_expr_binary_operator(): Bool_expr_binary_operatorContext;
    expr(_p: any): ExprContext;
    expr_atom(): Expr_atomContext;
    expr_interval(): Expr_intervalContext;
    interval_item(): Interval_itemContext;
    expr_concat(): Expr_concatContext;
    expr_concat_item(): Expr_concat_itemContext;
    expr_case(): Expr_caseContext;
    expr_case_simple(): Expr_case_simpleContext;
    expr_case_searched(): Expr_case_searchedContext;
    expr_cursor_attribute(): Expr_cursor_attributeContext;
    expr_agg_window_func(): Expr_agg_window_funcContext;
    expr_func_all_distinct(): Expr_func_all_distinctContext;
    expr_func_over_clause(): Expr_func_over_clauseContext;
    expr_func_partition_by_clause(): Expr_func_partition_by_clauseContext;
    expr_spec_func(): Expr_spec_funcContext;
    expr_func(): Expr_funcContext;
    expr_func_params(): Expr_func_paramsContext;
    func_param(): Func_paramContext;
    expr_select(): Expr_selectContext;
    expr_file(): Expr_fileContext;
    hive(): HiveContext;
    hive_item(): Hive_itemContext;
    host(): HostContext;
    host_cmd(): Host_cmdContext;
    host_stmt(): Host_stmtContext;
    file_name(): File_nameContext;
    date_literal(): Date_literalContext;
    timestamp_literal(): Timestamp_literalContext;
    ident(): IdentContext;
    string(): StringContext;
    int_number(): Int_numberContext;
    dec_number(): Dec_numberContext;
    bool_literal(): Bool_literalContext;
    null_const(): Null_constContext;
    non_reserved_words(): Non_reserved_wordsContext;
    sempred(localctx: any, ruleIndex: any, predIndex: any): any;
    block_end_sempred(localctx: any, predIndex: any): boolean;
    expr_stmt_sempred(localctx: any, predIndex: any): boolean;
    create_routine_params_sempred(localctx: any, predIndex: any): boolean;
    select_list_alias_sempred(localctx: any, predIndex: any): boolean;
    from_alias_clause_sempred(localctx: any, predIndex: any): boolean;
    delete_alias_sempred(localctx: any, predIndex: any): boolean;
    bool_expr_sempred(localctx: any, predIndex: any): any;
    expr_sempred(localctx: any, predIndex: any): any;
    func_param_sempred(localctx: any, predIndex: any): boolean;
}
export namespace HiveSql {
    export const EOF: number;
    export const T_ACTION: number;
    export const T_ADD2: number;
    export const T_ALL: number;
    export const T_ALLOCATE: number;
    export const T_ALTER: number;
    export const T_AND: number;
    export const T_ANSI_NULLS: number;
    export const T_ANSI_PADDING: number;
    export const T_AS: number;
    export const T_ASC: number;
    export const T_ASSOCIATE: number;
    export const T_AT: number;
    export const T_AUTO_INCREMENT: number;
    export const T_AVG: number;
    export const T_BATCHSIZE: number;
    export const T_BEGIN: number;
    export const T_BETWEEN: number;
    export const T_BIGINT: number;
    export const T_BINARY_DOUBLE: number;
    export const T_BINARY_FLOAT: number;
    export const T_BINARY_INTEGER: number;
    export const T_BIT: number;
    export const T_BODY: number;
    export const T_BREAK: number;
    export const T_BY: number;
    export const T_BYTE: number;
    export const T_CALL: number;
    export const T_CALLER: number;
    export const T_CASCADE: number;
    export const T_CASE: number;
    export const T_CASESPECIFIC: number;
    export const T_CAST: number;
    export const T_CHAR: number;
    export const T_CHARACTER: number;
    export const T_CHARSET: number;
    export const T_CLIENT: number;
    export const T_CLOSE: number;
    export const T_CLUSTERED: number;
    export const T_CMP: number;
    export const T_COLLECT: number;
    export const T_COLLECTION: number;
    export const T_COLUMN: number;
    export const T_COMMENT: number;
    export const T_CONSTANT: number;
    export const T_COMMIT: number;
    export const T_COMPRESS: number;
    export const T_CONCAT: number;
    export const T_CONDITION: number;
    export const T_CONSTRAINT: number;
    export const T_CONTINUE: number;
    export const T_COPY: number;
    export const T_COUNT: number;
    export const T_COUNT_BIG: number;
    export const T_CREATE: number;
    export const T_CREATION: number;
    export const T_CREATOR: number;
    export const T_CS: number;
    export const T_CURRENT: number;
    export const T_CURRENT_SCHEMA: number;
    export const T_CURSOR: number;
    export const T_DATABASE: number;
    export const T_DATA: number;
    export const T_DATE: number;
    export const T_DATETIME: number;
    export const T_DAY: number;
    export const T_DAYS: number;
    export const T_DEC: number;
    export const T_DECIMAL: number;
    export const T_DECLARE: number;
    export const T_DEFAULT: number;
    export const T_DEFERRED: number;
    export const T_DEFINED: number;
    export const T_DEFINER: number;
    export const T_DEFINITION: number;
    export const T_DELETE: number;
    export const T_DELIMITED: number;
    export const T_DELIMITER: number;
    export const T_DESC: number;
    export const T_DESCRIBE: number;
    export const T_DIAGNOSTICS: number;
    export const T_DIR: number;
    export const T_DIRECTORY: number;
    export const T_DISTINCT: number;
    export const T_DISTRIBUTE: number;
    export const T_DO: number;
    export const T_DOUBLE: number;
    export const T_DROP: number;
    export const T_DYNAMIC: number;
    export const T_ELSE: number;
    export const T_ELSEIF: number;
    export const T_ELSIF: number;
    export const T_ENABLE: number;
    export const T_END: number;
    export const T_ENGINE: number;
    export const T_ESCAPED: number;
    export const T_EXCEPT: number;
    export const T_EXEC: number;
    export const T_EXECUTE: number;
    export const T_EXCEPTION: number;
    export const T_EXCLUSIVE: number;
    export const T_EXISTS: number;
    export const T_EXIT: number;
    export const T_FALLBACK: number;
    export const T_FALSE: number;
    export const T_FETCH: number;
    export const T_FIELDS: number;
    export const T_FILE: number;
    export const T_FILES: number;
    export const T_FLOAT: number;
    export const T_FOR: number;
    export const T_FOREIGN: number;
    export const T_FORMAT: number;
    export const T_FOUND: number;
    export const T_FROM: number;
    export const T_FULL: number;
    export const T_FUNCTION: number;
    export const T_GET: number;
    export const T_GLOBAL: number;
    export const T_GO: number;
    export const T_GRANT: number;
    export const T_GROUP: number;
    export const T_HANDLER: number;
    export const T_HASH: number;
    export const T_HAVING: number;
    export const T_HDFS: number;
    export const T_HIVE: number;
    export const T_HOST: number;
    export const T_IDENTITY: number;
    export const T_IF: number;
    export const T_IGNORE: number;
    export const T_IMMEDIATE: number;
    export const T_IN: number;
    export const T_INCLUDE: number;
    export const T_INDEX: number;
    export const T_INITRANS: number;
    export const T_INNER: number;
    export const T_INOUT: number;
    export const T_INSERT: number;
    export const T_INT: number;
    export const T_INT2: number;
    export const T_INT4: number;
    export const T_INT8: number;
    export const T_INTEGER: number;
    export const T_INTERSECT: number;
    export const T_INTERVAL: number;
    export const T_INTO: number;
    export const T_INVOKER: number;
    export const T_IS: number;
    export const T_ISOPEN: number;
    export const T_ITEMS: number;
    export const T_JOIN: number;
    export const T_KEEP: number;
    export const T_KEY: number;
    export const T_KEYS: number;
    export const T_LANGUAGE: number;
    export const T_LEAVE: number;
    export const T_LEFT: number;
    export const T_LIKE: number;
    export const T_LIMIT: number;
    export const T_LINES: number;
    export const T_LOCAL: number;
    export const T_LOCATION: number;
    export const T_LOCATOR: number;
    export const T_LOCATORS: number;
    export const T_LOCKS: number;
    export const T_LOG: number;
    export const T_LOGGED: number;
    export const T_LOGGING: number;
    export const T_LOOP: number;
    export const T_MAP: number;
    export const T_MATCHED: number;
    export const T_MAX: number;
    export const T_MAXTRANS: number;
    export const T_MERGE: number;
    export const T_MESSAGE_TEXT: number;
    export const T_MICROSECOND: number;
    export const T_MICROSECONDS: number;
    export const T_MIN: number;
    export const T_MULTISET: number;
    export const T_NCHAR: number;
    export const T_NEW: number;
    export const T_NVARCHAR: number;
    export const T_NO: number;
    export const T_NOCOUNT: number;
    export const T_NOCOMPRESS: number;
    export const T_NOLOGGING: number;
    export const T_NONE: number;
    export const T_NOT: number;
    export const T_NOTFOUND: number;
    export const T_NULL: number;
    export const T_NUMERIC: number;
    export const T_NUMBER: number;
    export const T_OBJECT: number;
    export const T_OFF: number;
    export const T_ON: number;
    export const T_ONLY: number;
    export const T_OPEN: number;
    export const T_OR: number;
    export const T_ORDER: number;
    export const T_OUT: number;
    export const T_OUTER: number;
    export const T_OVER: number;
    export const T_OVERWRITE: number;
    export const T_OWNER: number;
    export const T_PACKAGE: number;
    export const T_PARTITION: number;
    export const T_PCTFREE: number;
    export const T_PCTUSED: number;
    export const T_PLS_INTEGER: number;
    export const T_PRECISION: number;
    export const T_PRESERVE: number;
    export const T_PRIMARY: number;
    export const T_PRINT: number;
    export const T_PROC: number;
    export const T_PROCEDURE: number;
    export const T_QUALIFY: number;
    export const T_QUERY_BAND: number;
    export const T_QUIT: number;
    export const T_QUOTED_IDENTIFIER: number;
    export const T_RAISE: number;
    export const T_REAL: number;
    export const T_REFERENCES: number;
    export const T_REGEXP: number;
    export const T_REPLACE: number;
    export const T_RESIGNAL: number;
    export const T_RESTRICT: number;
    export const T_RESULT: number;
    export const T_RESULT_SET_LOCATOR: number;
    export const T_RETURN: number;
    export const T_RETURNS: number;
    export const T_REVERSE: number;
    export const T_RIGHT: number;
    export const T_RLIKE: number;
    export const T_ROLE: number;
    export const T_ROLLBACK: number;
    export const T_ROW: number;
    export const T_ROWS: number;
    export const T_ROWTYPE: number;
    export const T_ROW_COUNT: number;
    export const T_RR: number;
    export const T_RS: number;
    export const T_PWD: number;
    export const T_TRIM: number;
    export const T_SCHEMA: number;
    export const T_SECOND: number;
    export const T_SECONDS: number;
    export const T_SECURITY: number;
    export const T_SEGMENT: number;
    export const T_SEL: number;
    export const T_SELECT: number;
    export const T_SET: number;
    export const T_SESSION: number;
    export const T_SESSIONS: number;
    export const T_SETS: number;
    export const T_SHARE: number;
    export const T_SIGNAL: number;
    export const T_SIMPLE_DOUBLE: number;
    export const T_SIMPLE_FLOAT: number;
    export const T_SIMPLE_INTEGER: number;
    export const T_SMALLDATETIME: number;
    export const T_SMALLINT: number;
    export const T_SQL: number;
    export const T_SQLEXCEPTION: number;
    export const T_SQLINSERT: number;
    export const T_SQLSTATE: number;
    export const T_SQLWARNING: number;
    export const T_STATS: number;
    export const T_STATISTICS: number;
    export const T_STEP: number;
    export const T_STORAGE: number;
    export const T_STORED: number;
    export const T_STRING: number;
    export const T_SUBDIR: number;
    export const T_SUBSTRING: number;
    export const T_SUM: number;
    export const T_SUMMARY: number;
    export const T_SYS_REFCURSOR: number;
    export const T_TABLE: number;
    export const T_TABLESPACE: number;
    export const T_TEMPORARY: number;
    export const T_TERMINATED: number;
    export const T_TEXTIMAGE_ON: number;
    export const T_THEN: number;
    export const T_TIMESTAMP: number;
    export const T_TINYINT: number;
    export const T_TITLE: number;
    export const T_TO: number;
    export const T_TOP: number;
    export const T_TRANSACTION: number;
    export const T_TRUE: number;
    export const T_TRUNCATE: number;
    export const T_TYPE: number;
    export const T_UNION: number;
    export const T_UNIQUE: number;
    export const T_UPDATE: number;
    export const T_UR: number;
    export const T_USE: number;
    export const T_USING: number;
    export const T_VALUE: number;
    export const T_VALUES: number;
    export const T_VAR: number;
    export const T_VARCHAR: number;
    export const T_VARCHAR2: number;
    export const T_VARYING: number;
    export const T_VOLATILE: number;
    export const T_WHEN: number;
    export const T_WHERE: number;
    export const T_WHILE: number;
    export const T_WITH: number;
    export const T_WITHOUT: number;
    export const T_WORK: number;
    export const T_XACT_ABORT: number;
    export const T_XML: number;
    export const T_YES: number;
    export const T_ACTIVITY_COUNT: number;
    export const T_CUME_DIST: number;
    export const T_CURRENT_DATE: number;
    export const T_CURRENT_TIMESTAMP: number;
    export const T_CURRENT_USER: number;
    export const T_DENSE_RANK: number;
    export const T_FIRST_VALUE: number;
    export const T_LAG: number;
    export const T_LAST_VALUE: number;
    export const T_LEAD: number;
    export const T_MAX_PART_STRING: number;
    export const T_MIN_PART_STRING: number;
    export const T_MAX_PART_INT: number;
    export const T_MIN_PART_INT: number;
    export const T_MAX_PART_DATE: number;
    export const T_MIN_PART_DATE: number;
    export const T_PART_COUNT: number;
    export const T_PART_LOC: number;
    export const T_RANK: number;
    export const T_ROW_NUMBER: number;
    export const T_STDEV: number;
    export const T_SYSDATE: number;
    export const T_VARIANCE: number;
    export const T_USER: number;
    export const T_ADD: number;
    export const T_COLON: number;
    export const T_COMMA: number;
    export const T_PIPE: number;
    export const T_DIV: number;
    export const T_DOT: number;
    export const T_DOT2: number;
    export const T_EQUAL: number;
    export const T_EQUAL2: number;
    export const T_SHARP: number;
    export const T_NOTE: number;
    export const T_NOTEQUAL: number;
    export const T_NOTEQUAL2: number;
    export const T_GREATER: number;
    export const T_GREATEREQUAL: number;
    export const T_LESS: number;
    export const T_LESSEQUAL: number;
    export const T_MUL: number;
    export const T_PRECENT: number;
    export const T_CALLS: number;
    export const T_OPEN_B: number;
    export const T_OPEN_P: number;
    export const T_OPEN_SB: number;
    export const T_CLOSE_B: number;
    export const T_CLOSE_P: number;
    export const T_CLOSE_SB: number;
    export const T_SEMICOLON: number;
    export const T_SUB: number;
    export const L_ID: number;
    export const L_S_STRING: number;
    export const L_D_STRING: number;
    export const L_INT: number;
    export const L_DEC: number;
    export const L_WS: number;
    export const L_M_COMMENT: number;
    export const L_S_COMMENT: number;
    export const L_FILE: number;
    export const L_LABEL: number;
    export const RULE_program: number;
    export const RULE_block: number;
    export const RULE_begin_end_block: number;
    export const RULE_single_block_stmt: number;
    export const RULE_block_end: number;
    export const RULE_proc_block: number;
    export const RULE_stmt: number;
    export const RULE_semicolon_stmt: number;
    export const RULE_exception_block: number;
    export const RULE_exception_block_item: number;
    export const RULE_null_stmt: number;
    export const RULE_expr_stmt: number;
    export const RULE_assignment_stmt: number;
    export const RULE_assignment_stmt_item: number;
    export const RULE_assignment_stmt_single_item: number;
    export const RULE_assignment_stmt_multiple_item: number;
    export const RULE_assignment_stmt_select_item: number;
    export const RULE_allocate_cursor_stmt: number;
    export const RULE_associate_locator_stmt: number;
    export const RULE_begin_transaction_stmt: number;
    export const RULE_break_stmt: number;
    export const RULE_call_stmt: number;
    export const RULE_declare_stmt: number;
    export const RULE_declare_block: number;
    export const RULE_declare_block_inplace: number;
    export const RULE_declare_stmt_item: number;
    export const RULE_declare_var_item: number;
    export const RULE_declare_condition_item: number;
    export const RULE_declare_cursor_item: number;
    export const RULE_cursor_with_return: number;
    export const RULE_cursor_without_return: number;
    export const RULE_declare_handler_item: number;
    export const RULE_declare_temporary_table_item: number;
    export const RULE_create_table_stmt: number;
    export const RULE_create_local_temp_table_stmt: number;
    export const RULE_create_table_definition: number;
    export const RULE_create_table_columns: number;
    export const RULE_create_table_columns_item: number;
    export const RULE_column_name: number;
    export const RULE_create_table_column_inline_cons: number;
    export const RULE_create_table_column_cons: number;
    export const RULE_create_table_fk_action: number;
    export const RULE_create_table_preoptions: number;
    export const RULE_create_table_preoptions_item: number;
    export const RULE_create_table_preoptions_td_item: number;
    export const RULE_create_table_options: number;
    export const RULE_create_table_options_item: number;
    export const RULE_create_table_options_ora_item: number;
    export const RULE_create_table_options_db2_item: number;
    export const RULE_create_table_options_td_item: number;
    export const RULE_create_table_options_hive_item: number;
    export const RULE_create_table_hive_row_format: number;
    export const RULE_create_table_hive_row_format_fields: number;
    export const RULE_create_table_options_mssql_item: number;
    export const RULE_create_table_options_mysql_item: number;
    export const RULE_alter_table_stmt: number;
    export const RULE_alter_table_item: number;
    export const RULE_alter_table_add_constraint: number;
    export const RULE_alter_table_add_constraint_item: number;
    export const RULE_dtype: number;
    export const RULE_dtype_len: number;
    export const RULE_dtype_attr: number;
    export const RULE_dtype_default: number;
    export const RULE_create_database_stmt: number;
    export const RULE_create_database_option: number;
    export const RULE_create_function_stmt: number;
    export const RULE_create_function_return: number;
    export const RULE_create_package_stmt: number;
    export const RULE_package_spec: number;
    export const RULE_package_spec_item: number;
    export const RULE_create_package_body_stmt: number;
    export const RULE_package_body: number;
    export const RULE_package_body_item: number;
    export const RULE_create_procedure_stmt: number;
    export const RULE_create_routine_params: number;
    export const RULE_create_routine_param_item: number;
    export const RULE_create_routine_options: number;
    export const RULE_create_routine_option: number;
    export const RULE_drop_stmt: number;
    export const RULE_end_transaction_stmt: number;
    export const RULE_exec_stmt: number;
    export const RULE_if_stmt: number;
    export const RULE_if_plsql_stmt: number;
    export const RULE_if_tsql_stmt: number;
    export const RULE_if_bteq_stmt: number;
    export const RULE_elseif_block: number;
    export const RULE_else_block: number;
    export const RULE_include_stmt: number;
    export const RULE_insert_stmt: number;
    export const RULE_insert_stmt_cols: number;
    export const RULE_insert_stmt_rows: number;
    export const RULE_insert_stmt_row: number;
    export const RULE_insert_directory_stmt: number;
    export const RULE_exit_stmt: number;
    export const RULE_get_diag_stmt: number;
    export const RULE_get_diag_stmt_item: number;
    export const RULE_get_diag_stmt_exception_item: number;
    export const RULE_get_diag_stmt_rowcount_item: number;
    export const RULE_grant_stmt: number;
    export const RULE_grant_stmt_item: number;
    export const RULE_leave_stmt: number;
    export const RULE_map_object_stmt: number;
    export const RULE_open_stmt: number;
    export const RULE_fetch_stmt: number;
    export const RULE_collect_stats_stmt: number;
    export const RULE_collect_stats_clause: number;
    export const RULE_close_stmt: number;
    export const RULE_cmp_stmt: number;
    export const RULE_cmp_source: number;
    export const RULE_copy_from_local_stmt: number;
    export const RULE_copy_stmt: number;
    export const RULE_copy_source: number;
    export const RULE_copy_target: number;
    export const RULE_copy_option: number;
    export const RULE_copy_file_option: number;
    export const RULE_commit_stmt: number;
    export const RULE_create_index_stmt: number;
    export const RULE_create_index_col: number;
    export const RULE_index_storage_clause: number;
    export const RULE_index_mssql_storage_clause: number;
    export const RULE_print_stmt: number;
    export const RULE_quit_stmt: number;
    export const RULE_raise_stmt: number;
    export const RULE_resignal_stmt: number;
    export const RULE_return_stmt: number;
    export const RULE_rollback_stmt: number;
    export const RULE_set_session_option: number;
    export const RULE_set_current_schema_option: number;
    export const RULE_set_mssql_session_option: number;
    export const RULE_set_teradata_session_option: number;
    export const RULE_signal_stmt: number;
    export const RULE_summary_stmt: number;
    export const RULE_truncate_stmt: number;
    export const RULE_use_stmt: number;
    export const RULE_values_into_stmt: number;
    export const RULE_while_stmt: number;
    export const RULE_for_cursor_stmt: number;
    export const RULE_for_range_stmt: number;
    export const RULE_label: number;
    export const RULE_using_clause: number;
    export const RULE_select_stmt: number;
    export const RULE_cte_select_stmt: number;
    export const RULE_cte_select_stmt_item: number;
    export const RULE_cte_select_cols: number;
    export const RULE_fullselect_stmt: number;
    export const RULE_fullselect_stmt_item: number;
    export const RULE_fullselect_set_clause: number;
    export const RULE_subselect_stmt: number;
    export const RULE_select_list: number;
    export const RULE_select_list_set: number;
    export const RULE_select_list_limit: number;
    export const RULE_select_list_item: number;
    export const RULE_select_list_alias: number;
    export const RULE_select_list_asterisk: number;
    export const RULE_into_clause: number;
    export const RULE_from_clause: number;
    export const RULE_from_table_clause: number;
    export const RULE_from_table_name_clause: number;
    export const RULE_from_subselect_clause: number;
    export const RULE_from_join_clause: number;
    export const RULE_from_join_type_clause: number;
    export const RULE_from_table_values_clause: number;
    export const RULE_from_table_values_row: number;
    export const RULE_from_alias_clause: number;
    export const RULE_table_name: number;
    export const RULE_where_clause: number;
    export const RULE_group_by_clause: number;
    export const RULE_having_clause: number;
    export const RULE_qualify_clause: number;
    export const RULE_order_by_clause: number;
    export const RULE_select_options: number;
    export const RULE_select_options_item: number;
    export const RULE_update_stmt: number;
    export const RULE_update_assignment: number;
    export const RULE_update_table: number;
    export const RULE_update_upsert: number;
    export const RULE_merge_stmt: number;
    export const RULE_merge_table: number;
    export const RULE_merge_condition: number;
    export const RULE_merge_action: number;
    export const RULE_delete_stmt: number;
    export const RULE_delete_alias: number;
    export const RULE_describe_stmt: number;
    export const RULE_bool_expr: number;
    export const RULE_bool_expr_atom: number;
    export const RULE_bool_expr_unary: number;
    export const RULE_bool_expr_single_in: number;
    export const RULE_bool_expr_multi_in: number;
    export const RULE_bool_expr_binary: number;
    export const RULE_bool_expr_logical_operator: number;
    export const RULE_bool_expr_binary_operator: number;
    export const RULE_expr: number;
    export const RULE_expr_atom: number;
    export const RULE_expr_interval: number;
    export const RULE_interval_item: number;
    export const RULE_expr_concat: number;
    export const RULE_expr_concat_item: number;
    export const RULE_expr_case: number;
    export const RULE_expr_case_simple: number;
    export const RULE_expr_case_searched: number;
    export const RULE_expr_cursor_attribute: number;
    export const RULE_expr_agg_window_func: number;
    export const RULE_expr_func_all_distinct: number;
    export const RULE_expr_func_over_clause: number;
    export const RULE_expr_func_partition_by_clause: number;
    export const RULE_expr_spec_func: number;
    export const RULE_expr_func: number;
    export const RULE_expr_func_params: number;
    export const RULE_func_param: number;
    export const RULE_expr_select: number;
    export const RULE_expr_file: number;
    export const RULE_hive: number;
    export const RULE_hive_item: number;
    export const RULE_host: number;
    export const RULE_host_cmd: number;
    export const RULE_host_stmt: number;
    export const RULE_file_name: number;
    export const RULE_date_literal: number;
    export const RULE_timestamp_literal: number;
    export const RULE_ident: number;
    export const RULE_string: number;
    export const RULE_int_number: number;
    export const RULE_dec_number: number;
    export const RULE_bool_literal: number;
    export const RULE_null_const: number;
    export const RULE_non_reserved_words: number;
    export { ProgramContext };
    export { BlockContext };
    export { Begin_end_blockContext };
    export { Single_block_stmtContext };
    export { Block_endContext };
    export { Proc_blockContext };
    export { StmtContext };
    export { Semicolon_stmtContext };
    export { Exception_blockContext };
    export { Exception_block_itemContext };
    export { Null_stmtContext };
    export { Expr_stmtContext };
    export { Assignment_stmtContext };
    export { Assignment_stmt_itemContext };
    export { Assignment_stmt_single_itemContext };
    export { Assignment_stmt_multiple_itemContext };
    export { Assignment_stmt_select_itemContext };
    export { Allocate_cursor_stmtContext };
    export { Associate_locator_stmtContext };
    export { Begin_transaction_stmtContext };
    export { Break_stmtContext };
    export { Call_stmtContext };
    export { Declare_stmtContext };
    export { Declare_blockContext };
    export { Declare_block_inplaceContext };
    export { Declare_stmt_itemContext };
    export { Declare_var_itemContext };
    export { Declare_condition_itemContext };
    export { Declare_cursor_itemContext };
    export { Cursor_with_returnContext };
    export { Cursor_without_returnContext };
    export { Declare_handler_itemContext };
    export { Declare_temporary_table_itemContext };
    export { Create_table_stmtContext };
    export { Create_local_temp_table_stmtContext };
    export { Create_table_definitionContext };
    export { Create_table_columnsContext };
    export { Create_table_columns_itemContext };
    export { Column_nameContext };
    export { Create_table_column_inline_consContext };
    export { Create_table_column_consContext };
    export { Create_table_fk_actionContext };
    export { Create_table_preoptionsContext };
    export { Create_table_preoptions_itemContext };
    export { Create_table_preoptions_td_itemContext };
    export { Create_table_optionsContext };
    export { Create_table_options_itemContext };
    export { Create_table_options_ora_itemContext };
    export { Create_table_options_db2_itemContext };
    export { Create_table_options_td_itemContext };
    export { Create_table_options_hive_itemContext };
    export { Create_table_hive_row_formatContext };
    export { Create_table_hive_row_format_fieldsContext };
    export { Create_table_options_mssql_itemContext };
    export { Create_table_options_mysql_itemContext };
    export { Alter_table_stmtContext };
    export { Alter_table_itemContext };
    export { Alter_table_add_constraintContext };
    export { Alter_table_add_constraint_itemContext };
    export { DtypeContext };
    export { Dtype_lenContext };
    export { Dtype_attrContext };
    export { Dtype_defaultContext };
    export { Create_database_stmtContext };
    export { Create_database_optionContext };
    export { Create_function_stmtContext };
    export { Create_function_returnContext };
    export { Create_package_stmtContext };
    export { Package_specContext };
    export { Package_spec_itemContext };
    export { Create_package_body_stmtContext };
    export { Package_bodyContext };
    export { Package_body_itemContext };
    export { Create_procedure_stmtContext };
    export { Create_routine_paramsContext };
    export { Create_routine_param_itemContext };
    export { Create_routine_optionsContext };
    export { Create_routine_optionContext };
    export { Drop_stmtContext };
    export { End_transaction_stmtContext };
    export { Exec_stmtContext };
    export { If_stmtContext };
    export { If_plsql_stmtContext };
    export { If_tsql_stmtContext };
    export { If_bteq_stmtContext };
    export { Elseif_blockContext };
    export { Else_blockContext };
    export { Include_stmtContext };
    export { Insert_stmtContext };
    export { Insert_stmt_colsContext };
    export { Insert_stmt_rowsContext };
    export { Insert_stmt_rowContext };
    export { Insert_directory_stmtContext };
    export { Exit_stmtContext };
    export { Get_diag_stmtContext };
    export { Get_diag_stmt_itemContext };
    export { Get_diag_stmt_exception_itemContext };
    export { Get_diag_stmt_rowcount_itemContext };
    export { Grant_stmtContext };
    export { Grant_stmt_itemContext };
    export { Leave_stmtContext };
    export { Map_object_stmtContext };
    export { Open_stmtContext };
    export { Fetch_stmtContext };
    export { Collect_stats_stmtContext };
    export { Collect_stats_clauseContext };
    export { Close_stmtContext };
    export { Cmp_stmtContext };
    export { Cmp_sourceContext };
    export { Copy_from_local_stmtContext };
    export { Copy_stmtContext };
    export { Copy_sourceContext };
    export { Copy_targetContext };
    export { Copy_optionContext };
    export { Copy_file_optionContext };
    export { Commit_stmtContext };
    export { Create_index_stmtContext };
    export { Create_index_colContext };
    export { Index_storage_clauseContext };
    export { Index_mssql_storage_clauseContext };
    export { Print_stmtContext };
    export { Quit_stmtContext };
    export { Raise_stmtContext };
    export { Resignal_stmtContext };
    export { Return_stmtContext };
    export { Rollback_stmtContext };
    export { Set_session_optionContext };
    export { Set_current_schema_optionContext };
    export { Set_mssql_session_optionContext };
    export { Set_teradata_session_optionContext };
    export { Signal_stmtContext };
    export { Summary_stmtContext };
    export { Truncate_stmtContext };
    export { Use_stmtContext };
    export { Values_into_stmtContext };
    export { While_stmtContext };
    export { For_cursor_stmtContext };
    export { For_range_stmtContext };
    export { LabelContext };
    export { Using_clauseContext };
    export { Select_stmtContext };
    export { Cte_select_stmtContext };
    export { Cte_select_stmt_itemContext };
    export { Cte_select_colsContext };
    export { Fullselect_stmtContext };
    export { Fullselect_stmt_itemContext };
    export { Fullselect_set_clauseContext };
    export { Subselect_stmtContext };
    export { Select_listContext };
    export { Select_list_setContext };
    export { Select_list_limitContext };
    export { Select_list_itemContext };
    export { Select_list_aliasContext };
    export { Select_list_asteriskContext };
    export { Into_clauseContext };
    export { From_clauseContext };
    export { From_table_clauseContext };
    export { From_table_name_clauseContext };
    export { From_subselect_clauseContext };
    export { From_join_clauseContext };
    export { From_join_type_clauseContext };
    export { From_table_values_clauseContext };
    export { From_table_values_rowContext };
    export { From_alias_clauseContext };
    export { Table_nameContext };
    export { Where_clauseContext };
    export { Group_by_clauseContext };
    export { Having_clauseContext };
    export { Qualify_clauseContext };
    export { Order_by_clauseContext };
    export { Select_optionsContext };
    export { Select_options_itemContext };
    export { Update_stmtContext };
    export { Update_assignmentContext };
    export { Update_tableContext };
    export { Update_upsertContext };
    export { Merge_stmtContext };
    export { Merge_tableContext };
    export { Merge_conditionContext };
    export { Merge_actionContext };
    export { Delete_stmtContext };
    export { Delete_aliasContext };
    export { Describe_stmtContext };
    export { Bool_expr_atomContext };
    export { Bool_expr_unaryContext };
    export { Bool_expr_single_inContext };
    export { Bool_expr_multi_inContext };
    export { Bool_expr_binaryContext };
    export { Bool_expr_logical_operatorContext };
    export { Bool_expr_binary_operatorContext };
    export { Expr_atomContext };
    export { Expr_intervalContext };
    export { Interval_itemContext };
    export { Expr_concatContext };
    export { Expr_concat_itemContext };
    export { Expr_caseContext };
    export { Expr_case_simpleContext };
    export { Expr_case_searchedContext };
    export { Expr_cursor_attributeContext };
    export { Expr_agg_window_funcContext };
    export { Expr_func_all_distinctContext };
    export { Expr_func_over_clauseContext };
    export { Expr_func_partition_by_clauseContext };
    export { Expr_spec_funcContext };
    export { Expr_funcContext };
    export { Expr_func_paramsContext };
    export { Func_paramContext };
    export { Expr_selectContext };
    export { Expr_fileContext };
    export { HiveContext };
    export { Hive_itemContext };
    export { HostContext };
    export { Host_cmdContext };
    export { Host_stmtContext };
    export { File_nameContext };
    export { Date_literalContext };
    export { Timestamp_literalContext };
    export { IdentContext };
    export { Double_quotedStringContext };
    export { Single_quotedStringContext };
    export { StringContext };
    export { Int_numberContext };
    export { Dec_numberContext };
    export { Bool_literalContext };
    export { Null_constContext };
    export { Non_reserved_wordsContext };
}
declare function ProgramContext(parser: any, parent: any, invokingState: any): this;
declare class ProgramContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof ProgramContext;
    block(): any;
    EOF(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function BlockContext(parser: any, parent: any, invokingState: any): this;
declare class BlockContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof BlockContext;
    begin_end_block(i: any): any;
    stmt(i: any): any;
    T_GO(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Begin_end_blockContext(parser: any, parent: any, invokingState: any): this;
declare class Begin_end_blockContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Begin_end_blockContext;
    T_BEGIN(): any;
    block(): any;
    block_end(): any;
    declare_block(): any;
    exception_block(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Single_block_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Single_block_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Single_block_stmtContext;
    T_BEGIN(): any;
    block(): any;
    block_end(): any;
    exception_block(): any;
    stmt(): any;
    T_SEMICOLON(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Block_endContext(parser: any, parent: any, invokingState: any): this;
declare class Block_endContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Block_endContext;
    T_END(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Proc_blockContext(parser: any, parent: any, invokingState: any): this;
declare class Proc_blockContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Proc_blockContext;
    begin_end_block(): any;
    stmt(i: any): any;
    T_GO(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function StmtContext(parser: any, parent: any, invokingState: any): this;
declare class StmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof StmtContext;
    assignment_stmt(): any;
    allocate_cursor_stmt(): any;
    alter_table_stmt(): any;
    associate_locator_stmt(): any;
    begin_transaction_stmt(): any;
    break_stmt(): any;
    call_stmt(): any;
    collect_stats_stmt(): any;
    close_stmt(): any;
    cmp_stmt(): any;
    copy_from_local_stmt(): any;
    copy_stmt(): any;
    commit_stmt(): any;
    create_database_stmt(): any;
    create_function_stmt(): any;
    create_index_stmt(): any;
    create_local_temp_table_stmt(): any;
    create_package_stmt(): any;
    create_package_body_stmt(): any;
    create_procedure_stmt(): any;
    create_table_stmt(): any;
    declare_stmt(): any;
    delete_stmt(): any;
    describe_stmt(): any;
    drop_stmt(): any;
    end_transaction_stmt(): any;
    exec_stmt(): any;
    exit_stmt(): any;
    fetch_stmt(): any;
    for_cursor_stmt(): any;
    for_range_stmt(): any;
    if_stmt(): any;
    include_stmt(): any;
    insert_stmt(): any;
    insert_directory_stmt(): any;
    get_diag_stmt(): any;
    grant_stmt(): any;
    leave_stmt(): any;
    map_object_stmt(): any;
    merge_stmt(): any;
    open_stmt(): any;
    print_stmt(): any;
    quit_stmt(): any;
    raise_stmt(): any;
    resignal_stmt(): any;
    return_stmt(): any;
    rollback_stmt(): any;
    select_stmt(): any;
    signal_stmt(): any;
    summary_stmt(): any;
    update_stmt(): any;
    use_stmt(): any;
    truncate_stmt(): any;
    values_into_stmt(): any;
    while_stmt(): any;
    label(): any;
    hive(): any;
    host(): any;
    null_stmt(): any;
    expr_stmt(): any;
    semicolon_stmt(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Semicolon_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Semicolon_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Semicolon_stmtContext;
    T_SEMICOLON(): any;
    T_CALLS(): any;
    T_SHARP(): any;
    T_DIV(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Exception_blockContext(parser: any, parent: any, invokingState: any): this;
declare class Exception_blockContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Exception_blockContext;
    T_EXCEPTION(): any;
    exception_block_item(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Exception_block_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Exception_block_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Exception_block_itemContext;
    T_WHEN(i: any): any;
    L_ID(): any;
    T_THEN(): any;
    block(): any;
    T_END(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Null_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Null_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Null_stmtContext;
    T_NULL(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_stmtContext;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Assignment_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Assignment_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Assignment_stmtContext;
    T_SET(): any;
    set_session_option(): any;
    assignment_stmt_item(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Assignment_stmt_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Assignment_stmt_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Assignment_stmt_itemContext;
    assignment_stmt_single_item(): any;
    assignment_stmt_multiple_item(): any;
    assignment_stmt_select_item(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Assignment_stmt_single_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Assignment_stmt_single_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Assignment_stmt_single_itemContext;
    ident(): any;
    T_EQUAL(): any;
    expr(): any;
    T_COLON(): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Assignment_stmt_multiple_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Assignment_stmt_multiple_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Assignment_stmt_multiple_itemContext;
    T_OPEN_P(i: any): any;
    ident(i: any): any;
    T_CLOSE_P(i: any): any;
    T_EQUAL(): any;
    expr(i: any): any;
    T_COMMA(i: any): any;
    T_COLON(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Assignment_stmt_select_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Assignment_stmt_select_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Assignment_stmt_select_itemContext;
    T_EQUAL(): any;
    T_OPEN_P(i: any): any;
    select_stmt(): any;
    T_CLOSE_P(i: any): any;
    ident(i: any): any;
    T_COLON(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Allocate_cursor_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Allocate_cursor_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Allocate_cursor_stmtContext;
    T_ALLOCATE(): any;
    ident(i: any): any;
    T_CURSOR(): any;
    T_FOR(): any;
    T_PROCEDURE(): any;
    T_RESULT(): any;
    T_SET(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Associate_locator_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Associate_locator_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Associate_locator_stmtContext;
    T_ASSOCIATE(): any;
    T_OPEN_P(): any;
    ident(i: any): any;
    T_CLOSE_P(): any;
    T_WITH(): any;
    T_PROCEDURE(): any;
    T_LOCATOR(): any;
    T_LOCATORS(): any;
    T_RESULT(): any;
    T_SET(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Begin_transaction_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Begin_transaction_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Begin_transaction_stmtContext;
    T_BEGIN(): any;
    T_TRANSACTION(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Break_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Break_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Break_stmtContext;
    T_BREAK(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Call_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Call_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Call_stmtContext;
    T_CALL(): any;
    ident(): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    expr_func_params(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Declare_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Declare_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Declare_stmtContext;
    T_DECLARE(): any;
    declare_stmt_item(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Declare_blockContext(parser: any, parent: any, invokingState: any): this;
declare class Declare_blockContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Declare_blockContext;
    T_DECLARE(): any;
    declare_stmt_item(i: any): any;
    T_SEMICOLON(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Declare_block_inplaceContext(parser: any, parent: any, invokingState: any): this;
declare class Declare_block_inplaceContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Declare_block_inplaceContext;
    declare_stmt_item(i: any): any;
    T_SEMICOLON(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Declare_stmt_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Declare_stmt_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Declare_stmt_itemContext;
    declare_cursor_item(): any;
    declare_condition_item(): any;
    declare_handler_item(): any;
    declare_var_item(): any;
    declare_temporary_table_item(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Declare_var_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Declare_var_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Declare_var_itemContext;
    ident(i: any): any;
    dtype(): any;
    T_COMMA(i: any): any;
    T_AS(): any;
    dtype_len(): any;
    dtype_attr(i: any): any;
    dtype_default(): any;
    T_CONSTANT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Declare_condition_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Declare_condition_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Declare_condition_itemContext;
    ident(): any;
    T_CONDITION(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Declare_cursor_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Declare_cursor_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Declare_cursor_itemContext;
    T_IS(): any;
    T_AS(): any;
    T_FOR(): any;
    T_CURSOR(): any;
    ident(): any;
    select_stmt(): any;
    expr(): any;
    cursor_with_return(): any;
    cursor_without_return(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Cursor_with_returnContext(parser: any, parent: any, invokingState: any): this;
declare class Cursor_with_returnContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Cursor_with_returnContext;
    T_WITH(): any;
    T_RETURN(): any;
    T_ONLY(): any;
    T_TO(): any;
    T_CALLER(): any;
    T_CLIENT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Cursor_without_returnContext(parser: any, parent: any, invokingState: any): this;
declare class Cursor_without_returnContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Cursor_without_returnContext;
    T_WITHOUT(): any;
    T_RETURN(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Declare_handler_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Declare_handler_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Declare_handler_itemContext;
    T_HANDLER(): any;
    T_FOR(): any;
    single_block_stmt(): any;
    T_CONTINUE(): any;
    T_EXIT(): any;
    T_SQLEXCEPTION(): any;
    T_SQLWARNING(): any;
    T_NOT(): any;
    T_FOUND(): any;
    ident(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Declare_temporary_table_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Declare_temporary_table_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Declare_temporary_table_itemContext;
    T_TEMPORARY(): any;
    T_TABLE(): any;
    ident(): any;
    create_table_definition(): any;
    T_GLOBAL(): any;
    create_table_preoptions(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_stmtContext;
    T_CREATE(): any;
    T_TABLE(): any;
    table_name(): any;
    create_table_definition(): any;
    T_IF(): any;
    T_NOT(): any;
    T_EXISTS(): any;
    create_table_preoptions(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_local_temp_table_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Create_local_temp_table_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_local_temp_table_stmtContext;
    T_CREATE(): any;
    T_TABLE(): any;
    ident(): any;
    create_table_definition(): any;
    T_LOCAL(): any;
    T_TEMPORARY(): any;
    T_VOLATILE(): any;
    create_table_preoptions(): any;
    T_SET(): any;
    T_MULTISET(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_definitionContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_definitionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_definitionContext;
    T_OPEN_P(): any;
    select_stmt(): any;
    T_CLOSE_P(): any;
    create_table_columns(): any;
    create_table_options(): any;
    T_AS(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_columnsContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_columnsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_columnsContext;
    create_table_columns_item(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_columns_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_columns_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_columns_itemContext;
    column_name(): any;
    dtype(): any;
    dtype_len(): any;
    dtype_attr(i: any): any;
    create_table_column_inline_cons(i: any): any;
    create_table_column_cons(): any;
    T_CONSTRAINT(): any;
    ident(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Column_nameContext(parser: any, parent: any, invokingState: any): this;
declare class Column_nameContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Column_nameContext;
    ident(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_column_inline_consContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_column_inline_consContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_column_inline_consContext;
    dtype_default(): any;
    T_NULL(): any;
    T_NOT(): any;
    T_PRIMARY(): any;
    T_KEY(): any;
    T_UNIQUE(): any;
    T_REFERENCES(): any;
    table_name(): any;
    T_OPEN_P(): any;
    ident(): any;
    T_CLOSE_P(): any;
    create_table_fk_action(i: any): any;
    T_IDENTITY(): any;
    L_INT(i: any): any;
    T_COMMA(i: any): any;
    T_AUTO_INCREMENT(): any;
    T_ENABLE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_column_consContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_column_consContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_column_consContext;
    T_PRIMARY(): any;
    T_KEY(): any;
    T_OPEN_P(i: any): any;
    ident(i: any): any;
    T_CLOSE_P(i: any): any;
    T_CLUSTERED(): any;
    T_COMMA(i: any): any;
    T_ENABLE(): any;
    index_storage_clause(): any;
    T_ASC(i: any): any;
    T_DESC(i: any): any;
    T_FOREIGN(): any;
    T_REFERENCES(): any;
    table_name(): any;
    create_table_fk_action(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_fk_actionContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_fk_actionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_fk_actionContext;
    T_ON(): any;
    T_UPDATE(): any;
    T_DELETE(): any;
    T_NO(): any;
    T_ACTION(): any;
    T_RESTRICT(): any;
    T_SET(): any;
    T_NULL(): any;
    T_DEFAULT(): any;
    T_CASCADE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_preoptionsContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_preoptionsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_preoptionsContext;
    create_table_preoptions_item(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_preoptions_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_preoptions_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_preoptions_itemContext;
    T_COMMA(): any;
    create_table_preoptions_td_item(): any;
    create_table_options_hive_item(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_preoptions_td_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_preoptions_td_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_preoptions_td_itemContext;
    T_LOG(): any;
    T_FALLBACK(): any;
    T_NO(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_optionsContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_optionsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_optionsContext;
    create_table_options_item(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_options_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_options_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_options_itemContext;
    T_ON(): any;
    T_COMMIT(): any;
    T_ROWS(): any;
    T_DELETE(): any;
    T_PRESERVE(): any;
    create_table_options_ora_item(): any;
    create_table_options_db2_item(): any;
    create_table_options_td_item(): any;
    create_table_options_hive_item(): any;
    create_table_options_mssql_item(): any;
    create_table_options_mysql_item(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_options_ora_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_options_ora_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_options_ora_itemContext;
    T_SEGMENT(): any;
    T_CREATION(): any;
    T_IMMEDIATE(): any;
    T_DEFERRED(): any;
    L_INT(i: any): any;
    T_PCTFREE(): any;
    T_PCTUSED(): any;
    T_INITRANS(): any;
    T_MAXTRANS(): any;
    T_NOCOMPRESS(): any;
    T_LOGGING(): any;
    T_NOLOGGING(): any;
    T_STORAGE(): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    ident(i: any): any;
    T_TABLESPACE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_options_db2_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_options_db2_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_options_db2_itemContext;
    T_IN(): any;
    ident(i: any): any;
    T_INDEX(): any;
    T_WITH(): any;
    T_REPLACE(): any;
    T_DISTRIBUTE(): any;
    T_BY(): any;
    T_HASH(): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    T_COMMA(i: any): any;
    T_LOGGED(): any;
    T_NOT(): any;
    T_COMPRESS(): any;
    T_YES(): any;
    T_NO(): any;
    T_DEFINITION(): any;
    T_ONLY(): any;
    T_RESTRICT(): any;
    T_ON(): any;
    T_DROP(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_options_td_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_options_td_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_options_td_itemContext;
    T_PRIMARY(): any;
    T_INDEX(): any;
    T_OPEN_P(): any;
    ident(i: any): any;
    T_CLOSE_P(): any;
    T_UNIQUE(): any;
    T_COMMA(i: any): any;
    T_WITH(): any;
    T_DATA(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_options_hive_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_options_hive_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_options_hive_itemContext;
    create_table_hive_row_format(): any;
    T_STORED(): any;
    T_AS(): any;
    ident(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_hive_row_formatContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_hive_row_formatContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_hive_row_formatContext;
    T_ROW(): any;
    T_FORMAT(): any;
    T_DELIMITED(): any;
    create_table_hive_row_format_fields(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_hive_row_format_fieldsContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_hive_row_format_fieldsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_hive_row_format_fieldsContext;
    T_FIELDS(): any;
    T_TERMINATED(): any;
    T_BY(i: any): any;
    expr(i: any): any;
    T_ESCAPED(): any;
    T_COLLECTION(): any;
    T_ITEMS(): any;
    T_MAP(): any;
    T_KEYS(): any;
    T_LINES(): any;
    T_NULL(): any;
    T_DEFINED(): any;
    T_AS(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_options_mssql_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_options_mssql_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_options_mssql_itemContext;
    T_ON(): any;
    ident(): any;
    T_TEXTIMAGE_ON(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_table_options_mysql_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_table_options_mysql_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_table_options_mysql_itemContext;
    T_AUTO_INCREMENT(): any;
    expr(): any;
    T_EQUAL(): any;
    T_COMMENT(): any;
    T_CHARACTER(): any;
    T_SET(): any;
    T_CHARSET(): any;
    T_DEFAULT(): any;
    T_ENGINE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Alter_table_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Alter_table_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Alter_table_stmtContext;
    T_ALTER(): any;
    T_TABLE(): any;
    table_name(): any;
    alter_table_item(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Alter_table_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Alter_table_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Alter_table_itemContext;
    alter_table_add_constraint(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Alter_table_add_constraintContext(parser: any, parent: any, invokingState: any): this;
declare class Alter_table_add_constraintContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Alter_table_add_constraintContext;
    T_ADD2(): any;
    alter_table_add_constraint_item(): any;
    T_CONSTRAINT(): any;
    ident(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Alter_table_add_constraint_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Alter_table_add_constraint_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Alter_table_add_constraint_itemContext;
    T_PRIMARY(): any;
    T_KEY(): any;
    T_OPEN_P(i: any): any;
    ident(i: any): any;
    T_CLOSE_P(i: any): any;
    T_CLUSTERED(): any;
    T_COMMA(i: any): any;
    T_ENABLE(): any;
    index_storage_clause(): any;
    T_ASC(i: any): any;
    T_DESC(i: any): any;
    T_FOREIGN(): any;
    T_REFERENCES(): any;
    table_name(): any;
    create_table_fk_action(i: any): any;
    T_DEFAULT(): any;
    expr(): any;
    T_FOR(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function DtypeContext(parser: any, parent: any, invokingState: any): this;
declare class DtypeContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof DtypeContext;
    T_CHAR(): any;
    T_BIGINT(): any;
    T_BINARY_DOUBLE(): any;
    T_BINARY_FLOAT(): any;
    T_BINARY_INTEGER(): any;
    T_BIT(): any;
    T_DATE(): any;
    T_DATETIME(): any;
    T_DEC(): any;
    T_DECIMAL(): any;
    T_DOUBLE(): any;
    T_PRECISION(): any;
    T_FLOAT(): any;
    T_INT(): any;
    T_INT2(): any;
    T_INT4(): any;
    T_INT8(): any;
    T_INTEGER(): any;
    T_NCHAR(): any;
    T_NVARCHAR(): any;
    T_NUMBER(): any;
    T_NUMERIC(): any;
    T_PLS_INTEGER(): any;
    T_REAL(): any;
    T_RESULT_SET_LOCATOR(): any;
    T_VARYING(): any;
    T_SIMPLE_FLOAT(): any;
    T_SIMPLE_DOUBLE(): any;
    T_SIMPLE_INTEGER(): any;
    T_SMALLINT(): any;
    T_SMALLDATETIME(): any;
    T_STRING(): any;
    T_SYS_REFCURSOR(): any;
    T_TIMESTAMP(): any;
    T_TINYINT(): any;
    T_VARCHAR(): any;
    T_VARCHAR2(): any;
    T_XML(): any;
    ident(): any;
    T_PRECENT(): any;
    T_TYPE(): any;
    T_ROWTYPE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Dtype_lenContext(parser: any, parent: any, invokingState: any): this;
declare class Dtype_lenContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Dtype_lenContext;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    L_INT(i: any): any;
    T_MAX(): any;
    T_COMMA(): any;
    T_CHAR(): any;
    T_BYTE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Dtype_attrContext(parser: any, parent: any, invokingState: any): this;
declare class Dtype_attrContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Dtype_attrContext;
    T_NULL(): any;
    T_NOT(): any;
    T_CHARACTER(): any;
    T_SET(): any;
    ident(): any;
    T_CASESPECIFIC(): any;
    T_CS(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Dtype_defaultContext(parser: any, parent: any, invokingState: any): this;
declare class Dtype_defaultContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Dtype_defaultContext;
    T_EQUAL(): any;
    expr(): any;
    T_COLON(): any;
    T_DEFAULT(): any;
    T_WITH(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_database_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Create_database_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_database_stmtContext;
    T_CREATE(): any;
    expr(): any;
    T_DATABASE(): any;
    T_SCHEMA(): any;
    T_IF(): any;
    T_NOT(): any;
    T_EXISTS(): any;
    create_database_option(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_database_optionContext(parser: any, parent: any, invokingState: any): this;
declare class Create_database_optionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_database_optionContext;
    T_COMMENT(): any;
    expr(): any;
    T_LOCATION(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_function_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Create_function_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_function_stmtContext;
    T_FUNCTION(): any;
    ident(): any;
    create_function_return(): any;
    single_block_stmt(): any;
    T_ALTER(): any;
    T_CREATE(): any;
    T_REPLACE(): any;
    create_routine_params(): any;
    declare_block_inplace(): any;
    T_AS(): any;
    T_IS(): any;
    T_OR(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_function_returnContext(parser: any, parent: any, invokingState: any): this;
declare class Create_function_returnContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_function_returnContext;
    dtype(): any;
    T_RETURN(): any;
    T_RETURNS(): any;
    dtype_len(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_package_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Create_package_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_package_stmtContext;
    T_PACKAGE(): any;
    ident(i: any): any;
    package_spec(): any;
    T_END(): any;
    T_AS(): any;
    T_IS(): any;
    T_ALTER(): any;
    T_CREATE(): any;
    T_REPLACE(): any;
    T_SEMICOLON(): any;
    T_OR(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Package_specContext(parser: any, parent: any, invokingState: any): this;
declare class Package_specContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Package_specContext;
    package_spec_item(i: any): any;
    T_SEMICOLON(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Package_spec_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Package_spec_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Package_spec_itemContext;
    declare_stmt_item(): any;
    T_FUNCTION(): any;
    ident(): any;
    create_function_return(): any;
    create_routine_params(): any;
    T_PROCEDURE(): any;
    T_PROC(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_package_body_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Create_package_body_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_package_body_stmtContext;
    T_PACKAGE(): any;
    T_BODY(): any;
    ident(i: any): any;
    package_body(): any;
    T_END(): any;
    T_AS(): any;
    T_IS(): any;
    T_ALTER(): any;
    T_CREATE(): any;
    T_REPLACE(): any;
    T_SEMICOLON(): any;
    T_OR(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Package_bodyContext(parser: any, parent: any, invokingState: any): this;
declare class Package_bodyContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Package_bodyContext;
    package_body_item(i: any): any;
    T_SEMICOLON(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Package_body_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Package_body_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Package_body_itemContext;
    declare_stmt_item(): any;
    create_function_stmt(): any;
    create_procedure_stmt(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_procedure_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Create_procedure_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_procedure_stmtContext;
    ident(i: any): any;
    proc_block(): any;
    T_PROCEDURE(): any;
    T_PROC(): any;
    T_ALTER(): any;
    T_CREATE(): any;
    T_REPLACE(): any;
    create_routine_params(): any;
    create_routine_options(): any;
    declare_block_inplace(): any;
    label(): any;
    T_SEMICOLON(): any;
    T_AS(): any;
    T_IS(): any;
    T_OR(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_routine_paramsContext(parser: any, parent: any, invokingState: any): this;
declare class Create_routine_paramsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_routine_paramsContext;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    create_routine_param_item(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_routine_param_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Create_routine_param_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_routine_param_itemContext;
    ident(): any;
    dtype(): any;
    T_IN(): any;
    T_OUT(): any;
    T_INOUT(): any;
    dtype_len(): any;
    dtype_attr(i: any): any;
    dtype_default(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_routine_optionsContext(parser: any, parent: any, invokingState: any): this;
declare class Create_routine_optionsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_routine_optionsContext;
    create_routine_option(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_routine_optionContext(parser: any, parent: any, invokingState: any): this;
declare class Create_routine_optionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_routine_optionContext;
    T_LANGUAGE(): any;
    T_SQL(): any;
    T_SECURITY(): any;
    T_CREATOR(): any;
    T_DEFINER(): any;
    T_INVOKER(): any;
    T_OWNER(): any;
    T_RESULT(): any;
    T_SETS(): any;
    L_INT(): any;
    T_DYNAMIC(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Drop_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Drop_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Drop_stmtContext;
    T_DROP(): any;
    T_TABLE(): any;
    table_name(): any;
    T_IF(): any;
    T_EXISTS(): any;
    expr(): any;
    T_DATABASE(): any;
    T_SCHEMA(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function End_transaction_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class End_transaction_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof End_transaction_stmtContext;
    T_END(): any;
    T_TRANSACTION(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Exec_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Exec_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Exec_stmtContext;
    expr(): any;
    T_EXEC(): any;
    T_EXECUTE(): any;
    T_IMMEDIATE(): any;
    T_OPEN_P(): any;
    expr_func_params(): any;
    T_CLOSE_P(): any;
    T_INTO(): any;
    L_ID(i: any): any;
    using_clause(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function If_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class If_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof If_stmtContext;
    if_plsql_stmt(): any;
    if_tsql_stmt(): any;
    if_bteq_stmt(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function If_plsql_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class If_plsql_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof If_plsql_stmtContext;
    T_IF(i: any): any;
    bool_expr(): any;
    T_THEN(): any;
    block(): any;
    T_END(): any;
    elseif_block(i: any): any;
    else_block(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function If_tsql_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class If_tsql_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof If_tsql_stmtContext;
    T_IF(): any;
    bool_expr(): any;
    single_block_stmt(i: any): any;
    T_ELSE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function If_bteq_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class If_bteq_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof If_bteq_stmtContext;
    T_DOT(): any;
    T_IF(): any;
    bool_expr(): any;
    T_THEN(): any;
    single_block_stmt(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Elseif_blockContext(parser: any, parent: any, invokingState: any): this;
declare class Elseif_blockContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Elseif_blockContext;
    bool_expr(): any;
    T_THEN(): any;
    block(): any;
    T_ELSIF(): any;
    T_ELSEIF(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Else_blockContext(parser: any, parent: any, invokingState: any): this;
declare class Else_blockContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Else_blockContext;
    T_ELSE(): any;
    block(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Include_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Include_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Include_stmtContext;
    T_INCLUDE(): any;
    file_name(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Insert_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Insert_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Insert_stmtContext;
    T_INSERT(): any;
    table_name(): any;
    T_OVERWRITE(): any;
    T_TABLE(): any;
    T_INTO(): any;
    select_stmt(): any;
    insert_stmt_rows(): any;
    insert_stmt_cols(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Insert_stmt_colsContext(parser: any, parent: any, invokingState: any): this;
declare class Insert_stmt_colsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Insert_stmt_colsContext;
    T_OPEN_P(): any;
    ident(i: any): any;
    T_CLOSE_P(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Insert_stmt_rowsContext(parser: any, parent: any, invokingState: any): this;
declare class Insert_stmt_rowsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Insert_stmt_rowsContext;
    T_VALUES(): any;
    insert_stmt_row(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Insert_stmt_rowContext(parser: any, parent: any, invokingState: any): this;
declare class Insert_stmt_rowContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Insert_stmt_rowContext;
    T_OPEN_P(): any;
    expr(i: any): any;
    T_CLOSE_P(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Insert_directory_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Insert_directory_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Insert_directory_stmtContext;
    T_INSERT(): any;
    T_OVERWRITE(): any;
    T_DIRECTORY(): any;
    expr_file(): any;
    expr_select(): any;
    T_LOCAL(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Exit_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Exit_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Exit_stmtContext;
    T_EXIT(): any;
    L_ID(): any;
    T_WHEN(): any;
    bool_expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Get_diag_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Get_diag_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Get_diag_stmtContext;
    T_GET(): any;
    T_DIAGNOSTICS(): any;
    get_diag_stmt_item(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Get_diag_stmt_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Get_diag_stmt_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Get_diag_stmt_itemContext;
    get_diag_stmt_exception_item(): any;
    get_diag_stmt_rowcount_item(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Get_diag_stmt_exception_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Get_diag_stmt_exception_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Get_diag_stmt_exception_itemContext;
    T_EXCEPTION(): any;
    L_INT(): any;
    ident(): any;
    T_EQUAL(): any;
    T_MESSAGE_TEXT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Get_diag_stmt_rowcount_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Get_diag_stmt_rowcount_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Get_diag_stmt_rowcount_itemContext;
    ident(): any;
    T_EQUAL(): any;
    T_ROW_COUNT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Grant_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Grant_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Grant_stmtContext;
    T_GRANT(): any;
    grant_stmt_item(i: any): any;
    T_TO(): any;
    T_ROLE(): any;
    ident(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Grant_stmt_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Grant_stmt_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Grant_stmt_itemContext;
    T_EXECUTE(): any;
    T_ON(): any;
    T_PROCEDURE(): any;
    ident(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Leave_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Leave_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Leave_stmtContext;
    T_LEAVE(): any;
    L_ID(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Map_object_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Map_object_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Map_object_stmtContext;
    T_MAP(): any;
    T_OBJECT(): any;
    expr(i: any): any;
    T_TO(): any;
    T_AT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Open_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Open_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Open_stmtContext;
    T_OPEN(): any;
    L_ID(): any;
    T_FOR(): any;
    select_stmt(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Fetch_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Fetch_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Fetch_stmtContext;
    T_FETCH(): any;
    L_ID(i: any): any;
    T_INTO(): any;
    T_FROM(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Collect_stats_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Collect_stats_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Collect_stats_stmtContext;
    T_COLLECT(): any;
    T_ON(): any;
    table_name(): any;
    T_STATISTICS(): any;
    T_STATS(): any;
    collect_stats_clause(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Collect_stats_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Collect_stats_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Collect_stats_clauseContext;
    T_COLUMN(): any;
    T_OPEN_P(): any;
    ident(i: any): any;
    T_CLOSE_P(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Close_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Close_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Close_stmtContext;
    T_CLOSE(): any;
    L_ID(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Cmp_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Cmp_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Cmp_stmtContext;
    T_CMP(): any;
    cmp_source(i: any): any;
    T_COMMA(): any;
    T_ROW_COUNT(): any;
    T_SUM(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Cmp_sourceContext(parser: any, parent: any, invokingState: any): this;
declare class Cmp_sourceContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Cmp_sourceContext;
    table_name(): any;
    T_OPEN_P(): any;
    select_stmt(): any;
    T_CLOSE_P(): any;
    T_AT(): any;
    ident(): any;
    where_clause(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Copy_from_local_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Copy_from_local_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Copy_from_local_stmtContext;
    T_COPY(): any;
    T_FROM(): any;
    T_LOCAL(): any;
    copy_source(i: any): any;
    T_TO(): any;
    copy_target(): any;
    T_COMMA(i: any): any;
    copy_file_option(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Copy_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Copy_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Copy_stmtContext;
    T_COPY(): any;
    T_TO(): any;
    copy_target(): any;
    table_name(): any;
    T_OPEN_P(): any;
    select_stmt(): any;
    T_CLOSE_P(): any;
    T_HDFS(): any;
    copy_option(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Copy_sourceContext(parser: any, parent: any, invokingState: any): this;
declare class Copy_sourceContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Copy_sourceContext;
    file_name(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Copy_targetContext(parser: any, parent: any, invokingState: any): this;
declare class Copy_targetContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Copy_targetContext;
    file_name(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Copy_optionContext(parser: any, parent: any, invokingState: any): this;
declare class Copy_optionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Copy_optionContext;
    T_AT(): any;
    ident(): any;
    T_BATCHSIZE(): any;
    expr(): any;
    T_DELIMITER(): any;
    T_SQLINSERT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Copy_file_optionContext(parser: any, parent: any, invokingState: any): this;
declare class Copy_file_optionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Copy_file_optionContext;
    T_DELETE(): any;
    T_IGNORE(): any;
    T_OVERWRITE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Commit_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Commit_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Commit_stmtContext;
    T_COMMIT(): any;
    T_WORK(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_index_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Create_index_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_index_stmtContext;
    T_CREATE(): any;
    T_INDEX(): any;
    ident(): any;
    T_ON(): any;
    table_name(): any;
    T_OPEN_P(): any;
    create_index_col(i: any): any;
    T_CLOSE_P(): any;
    T_UNIQUE(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Create_index_colContext(parser: any, parent: any, invokingState: any): this;
declare class Create_index_colContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Create_index_colContext;
    ident(): any;
    T_ASC(): any;
    T_DESC(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Index_storage_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Index_storage_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Index_storage_clauseContext;
    index_mssql_storage_clause(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Index_mssql_storage_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Index_mssql_storage_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Index_mssql_storage_clauseContext;
    T_WITH(): any;
    T_OPEN_P(): any;
    ident(i: any): any;
    T_EQUAL(i: any): any;
    T_CLOSE_P(): any;
    T_COMMA(i: any): any;
    create_table_options_mssql_item(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Print_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Print_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Print_stmtContext;
    T_PRINT(): any;
    expr(): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Quit_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Quit_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Quit_stmtContext;
    T_QUIT(): any;
    T_DOT(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Raise_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Raise_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Raise_stmtContext;
    T_RAISE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Resignal_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Resignal_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Resignal_stmtContext;
    T_RESIGNAL(): any;
    T_SQLSTATE(): any;
    expr(i: any): any;
    T_VALUE(): any;
    T_SET(): any;
    T_MESSAGE_TEXT(): any;
    T_EQUAL(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Return_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Return_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Return_stmtContext;
    T_RETURN(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Rollback_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Rollback_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Rollback_stmtContext;
    T_ROLLBACK(): any;
    T_WORK(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Set_session_optionContext(parser: any, parent: any, invokingState: any): this;
declare class Set_session_optionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Set_session_optionContext;
    set_current_schema_option(): any;
    set_mssql_session_option(): any;
    set_teradata_session_option(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Set_current_schema_optionContext(parser: any, parent: any, invokingState: any): this;
declare class Set_current_schema_optionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Set_current_schema_optionContext;
    expr(): any;
    T_CURRENT_SCHEMA(): any;
    T_EQUAL(): any;
    T_SCHEMA(): any;
    T_CURRENT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Set_mssql_session_optionContext(parser: any, parent: any, invokingState: any): this;
declare class Set_mssql_session_optionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Set_mssql_session_optionContext;
    T_ANSI_NULLS(): any;
    T_ANSI_PADDING(): any;
    T_NOCOUNT(): any;
    T_QUOTED_IDENTIFIER(): any;
    T_XACT_ABORT(): any;
    T_ON(): any;
    T_OFF(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Set_teradata_session_optionContext(parser: any, parent: any, invokingState: any): this;
declare class Set_teradata_session_optionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Set_teradata_session_optionContext;
    T_QUERY_BAND(): any;
    T_EQUAL(): any;
    T_FOR(): any;
    T_TRANSACTION(): any;
    T_SESSION(): any;
    expr(): any;
    T_NONE(): any;
    T_UPDATE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Signal_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Signal_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Signal_stmtContext;
    T_SIGNAL(): any;
    ident(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Summary_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Summary_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Summary_stmtContext;
    T_SUMMARY(): any;
    T_FOR(): any;
    select_stmt(): any;
    table_name(): any;
    T_TOP(): any;
    expr(i: any): any;
    where_clause(): any;
    T_LIMIT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Truncate_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Truncate_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Truncate_stmtContext;
    T_TRUNCATE(): any;
    table_name(): any;
    T_TABLE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Use_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Use_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Use_stmtContext;
    T_USE(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Values_into_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Values_into_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Values_into_stmtContext;
    T_VALUES(): any;
    expr(i: any): any;
    T_INTO(): any;
    ident(i: any): any;
    T_OPEN_P(i: any): any;
    T_COMMA(i: any): any;
    T_CLOSE_P(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function While_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class While_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof While_stmtContext;
    T_WHILE(i: any): any;
    bool_expr(): any;
    block(): any;
    T_END(): any;
    T_DO(): any;
    T_LOOP(i: any): any;
    T_THEN(): any;
    T_BEGIN(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function For_cursor_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class For_cursor_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof For_cursor_stmtContext;
    T_FOR(): any;
    L_ID(): any;
    T_IN(): any;
    select_stmt(): any;
    T_LOOP(i: any): any;
    block(): any;
    T_END(): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function For_range_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class For_range_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof For_range_stmtContext;
    T_FOR(): any;
    L_ID(): any;
    T_IN(): any;
    expr(i: any): any;
    T_DOT2(): any;
    T_LOOP(i: any): any;
    block(): any;
    T_END(): any;
    T_REVERSE(): any;
    T_BY(): any;
    T_STEP(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function LabelContext(parser: any, parent: any, invokingState: any): this;
declare class LabelContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof LabelContext;
    L_LABEL(): any;
    T_LESS(i: any): any;
    L_ID(): any;
    T_GREATER(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Using_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Using_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Using_clauseContext;
    T_USING(): any;
    expr(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Select_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Select_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Select_stmtContext;
    fullselect_stmt(): any;
    cte_select_stmt(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Cte_select_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Cte_select_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Cte_select_stmtContext;
    T_WITH(): any;
    cte_select_stmt_item(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Cte_select_stmt_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Cte_select_stmt_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Cte_select_stmt_itemContext;
    ident(): any;
    T_AS(): any;
    T_OPEN_P(): any;
    fullselect_stmt(): any;
    T_CLOSE_P(): any;
    cte_select_cols(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Cte_select_colsContext(parser: any, parent: any, invokingState: any): this;
declare class Cte_select_colsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Cte_select_colsContext;
    T_OPEN_P(): any;
    ident(i: any): any;
    T_CLOSE_P(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Fullselect_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Fullselect_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Fullselect_stmtContext;
    fullselect_stmt_item(i: any): any;
    fullselect_set_clause(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Fullselect_stmt_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Fullselect_stmt_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Fullselect_stmt_itemContext;
    subselect_stmt(): any;
    T_OPEN_P(): any;
    fullselect_stmt(): any;
    T_CLOSE_P(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Fullselect_set_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Fullselect_set_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Fullselect_set_clauseContext;
    T_UNION(): any;
    T_ALL(): any;
    T_EXCEPT(): any;
    T_INTERSECT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Subselect_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Subselect_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Subselect_stmtContext;
    select_list(): any;
    T_SELECT(): any;
    T_SEL(): any;
    into_clause(): any;
    from_clause(): any;
    where_clause(): any;
    group_by_clause(): any;
    having_clause(): any;
    qualify_clause(): any;
    order_by_clause(): any;
    select_options(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Select_listContext(parser: any, parent: any, invokingState: any): this;
declare class Select_listContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Select_listContext;
    select_list_item(i: any): any;
    select_list_set(): any;
    select_list_limit(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Select_list_setContext(parser: any, parent: any, invokingState: any): this;
declare class Select_list_setContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Select_list_setContext;
    T_ALL(): any;
    T_DISTINCT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Select_list_limitContext(parser: any, parent: any, invokingState: any): this;
declare class Select_list_limitContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Select_list_limitContext;
    T_TOP(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Select_list_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Select_list_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Select_list_itemContext;
    expr(): any;
    select_list_asterisk(): any;
    ident(): any;
    T_EQUAL(): any;
    select_list_alias(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Select_list_aliasContext(parser: any, parent: any, invokingState: any): this;
declare class Select_list_aliasContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Select_list_aliasContext;
    ident(): any;
    T_AS(): any;
    T_OPEN_P(): any;
    T_TITLE(): any;
    L_S_STRING(): any;
    T_CLOSE_P(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Select_list_asteriskContext(parser: any, parent: any, invokingState: any): this;
declare class Select_list_asteriskContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Select_list_asteriskContext;
    T_MUL(): any;
    L_ID(): any;
    T_DOT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Into_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Into_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Into_clauseContext;
    T_INTO(): any;
    ident(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function From_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class From_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof From_clauseContext;
    T_FROM(): any;
    from_table_clause(): any;
    from_join_clause(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function From_table_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class From_table_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof From_table_clauseContext;
    from_table_name_clause(): any;
    from_subselect_clause(): any;
    from_table_values_clause(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function From_table_name_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class From_table_name_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof From_table_name_clauseContext;
    table_name(): any;
    from_alias_clause(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function From_subselect_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class From_subselect_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof From_subselect_clauseContext;
    T_OPEN_P(): any;
    select_stmt(): any;
    T_CLOSE_P(): any;
    from_alias_clause(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function From_join_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class From_join_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof From_join_clauseContext;
    T_COMMA(): any;
    from_table_clause(): any;
    from_join_type_clause(): any;
    T_ON(): any;
    bool_expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function From_join_type_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class From_join_type_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof From_join_type_clauseContext;
    T_JOIN(): any;
    T_INNER(): any;
    T_LEFT(): any;
    T_RIGHT(): any;
    T_FULL(): any;
    T_OUTER(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function From_table_values_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class From_table_values_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof From_table_values_clauseContext;
    T_TABLE(): any;
    T_OPEN_P(): any;
    T_VALUES(): any;
    from_table_values_row(i: any): any;
    T_CLOSE_P(): any;
    T_COMMA(i: any): any;
    from_alias_clause(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function From_table_values_rowContext(parser: any, parent: any, invokingState: any): this;
declare class From_table_values_rowContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof From_table_values_rowContext;
    expr(i: any): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function From_alias_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class From_alias_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof From_alias_clauseContext;
    ident(): any;
    T_AS(): any;
    T_OPEN_P(): any;
    L_ID(i: any): any;
    T_CLOSE_P(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Table_nameContext(parser: any, parent: any, invokingState: any): this;
declare class Table_nameContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Table_nameContext;
    ident(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Where_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Where_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Where_clauseContext;
    T_WHERE(): any;
    bool_expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Group_by_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Group_by_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Group_by_clauseContext;
    T_GROUP(): any;
    T_BY(): any;
    expr(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Having_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Having_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Having_clauseContext;
    T_HAVING(): any;
    bool_expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Qualify_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Qualify_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Qualify_clauseContext;
    T_QUALIFY(): any;
    bool_expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Order_by_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Order_by_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Order_by_clauseContext;
    T_ORDER(): any;
    T_BY(): any;
    expr(i: any): any;
    T_COMMA(i: any): any;
    T_ASC(i: any): any;
    T_DESC(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Select_optionsContext(parser: any, parent: any, invokingState: any): this;
declare class Select_optionsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Select_optionsContext;
    select_options_item(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Select_options_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Select_options_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Select_options_itemContext;
    T_LIMIT(): any;
    expr(): any;
    T_WITH(): any;
    T_RR(): any;
    T_RS(): any;
    T_CS(): any;
    T_UR(): any;
    T_USE(): any;
    T_AND(): any;
    T_KEEP(): any;
    T_LOCKS(): any;
    T_EXCLUSIVE(): any;
    T_UPDATE(): any;
    T_SHARE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Update_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Update_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Update_stmtContext;
    T_UPDATE(): any;
    update_table(): any;
    T_SET(): any;
    update_assignment(): any;
    where_clause(): any;
    update_upsert(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Update_assignmentContext(parser: any, parent: any, invokingState: any): this;
declare class Update_assignmentContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Update_assignmentContext;
    assignment_stmt_item(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Update_tableContext(parser: any, parent: any, invokingState: any): this;
declare class Update_tableContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Update_tableContext;
    table_name(): any;
    T_OPEN_P(): any;
    select_stmt(): any;
    T_CLOSE_P(): any;
    ident(): any;
    from_clause(): any;
    T_AS(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Update_upsertContext(parser: any, parent: any, invokingState: any): this;
declare class Update_upsertContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Update_upsertContext;
    T_ELSE(): any;
    insert_stmt(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Merge_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Merge_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Merge_stmtContext;
    T_MERGE(): any;
    T_INTO(): any;
    merge_table(i: any): any;
    T_USING(): any;
    T_ON(): any;
    bool_expr(): any;
    merge_condition(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Merge_tableContext(parser: any, parent: any, invokingState: any): this;
declare class Merge_tableContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Merge_tableContext;
    table_name(): any;
    ident(): any;
    T_OPEN_P(): any;
    select_stmt(): any;
    T_CLOSE_P(): any;
    T_AS(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Merge_conditionContext(parser: any, parent: any, invokingState: any): this;
declare class Merge_conditionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Merge_conditionContext;
    T_WHEN(): any;
    T_MATCHED(): any;
    T_THEN(): any;
    merge_action(): any;
    T_NOT(): any;
    T_AND(): any;
    bool_expr(): any;
    T_ELSE(): any;
    T_IGNORE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Merge_actionContext(parser: any, parent: any, invokingState: any): this;
declare class Merge_actionContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Merge_actionContext;
    T_INSERT(): any;
    T_VALUES(): any;
    insert_stmt_row(): any;
    insert_stmt_cols(): any;
    T_UPDATE(): any;
    T_SET(): any;
    assignment_stmt_item(i: any): any;
    T_COMMA(i: any): any;
    where_clause(): any;
    T_DELETE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Delete_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Delete_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Delete_stmtContext;
    T_DELETE(): any;
    table_name(): any;
    T_FROM(): any;
    delete_alias(): any;
    where_clause(): any;
    T_ALL(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Delete_aliasContext(parser: any, parent: any, invokingState: any): this;
declare class Delete_aliasContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Delete_aliasContext;
    ident(): any;
    T_AS(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Describe_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Describe_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Describe_stmtContext;
    table_name(): any;
    T_DESCRIBE(): any;
    T_DESC(): any;
    T_TABLE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Bool_exprContext(parser: any, parent: any, invokingState: any): this;
declare class Bool_exprContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Bool_exprContext;
    T_OPEN_P(): any;
    bool_expr(i: any): any;
    T_CLOSE_P(): any;
    T_NOT(): any;
    bool_expr_atom(): any;
    bool_expr_logical_operator(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Bool_expr_atomContext(parser: any, parent: any, invokingState: any): this;
declare class Bool_expr_atomContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Bool_expr_atomContext;
    bool_expr_unary(): any;
    bool_expr_binary(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Bool_expr_unaryContext(parser: any, parent: any, invokingState: any): this;
declare class Bool_expr_unaryContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Bool_expr_unaryContext;
    expr(i: any): any;
    T_IS(): any;
    T_NULL(): any;
    T_NOT(): any;
    T_BETWEEN(): any;
    T_AND(): any;
    T_EXISTS(): any;
    T_OPEN_P(): any;
    select_stmt(): any;
    T_CLOSE_P(): any;
    bool_expr_single_in(): any;
    bool_expr_multi_in(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Bool_expr_single_inContext(parser: any, parent: any, invokingState: any): this;
declare class Bool_expr_single_inContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Bool_expr_single_inContext;
    expr(i: any): any;
    T_IN(): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    select_stmt(): any;
    T_NOT(): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Bool_expr_multi_inContext(parser: any, parent: any, invokingState: any): this;
declare class Bool_expr_multi_inContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Bool_expr_multi_inContext;
    T_OPEN_P(i: any): any;
    expr(i: any): any;
    T_CLOSE_P(i: any): any;
    T_IN(): any;
    select_stmt(): any;
    T_COMMA(i: any): any;
    T_NOT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Bool_expr_binaryContext(parser: any, parent: any, invokingState: any): this;
declare class Bool_expr_binaryContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Bool_expr_binaryContext;
    expr(i: any): any;
    bool_expr_binary_operator(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Bool_expr_logical_operatorContext(parser: any, parent: any, invokingState: any): this;
declare class Bool_expr_logical_operatorContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Bool_expr_logical_operatorContext;
    T_AND(): any;
    T_OR(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Bool_expr_binary_operatorContext(parser: any, parent: any, invokingState: any): this;
declare class Bool_expr_binary_operatorContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Bool_expr_binary_operatorContext;
    T_EQUAL(): any;
    T_EQUAL2(): any;
    T_NOTEQUAL(): any;
    T_NOTEQUAL2(): any;
    T_LESS(): any;
    T_LESSEQUAL(): any;
    T_GREATER(): any;
    T_GREATEREQUAL(): any;
    T_LIKE(): any;
    T_RLIKE(): any;
    T_REGEXP(): any;
    T_NOT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function ExprContext(parser: any, parent: any, invokingState: any): this;
declare class ExprContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof ExprContext;
    T_OPEN_P(): any;
    select_stmt(): any;
    T_CLOSE_P(): any;
    expr(i: any): any;
    expr_interval(): any;
    expr_concat(): any;
    expr_case(): any;
    expr_cursor_attribute(): any;
    expr_agg_window_func(): any;
    expr_spec_func(): any;
    expr_func(): any;
    expr_atom(): any;
    T_MUL(): any;
    T_DIV(): any;
    T_ADD(): any;
    T_SUB(): any;
    interval_item(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_atomContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_atomContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_atomContext;
    date_literal(): any;
    timestamp_literal(): any;
    bool_literal(): any;
    ident(): any;
    string(): any;
    dec_number(): any;
    int_number(): any;
    null_const(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_intervalContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_intervalContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_intervalContext;
    T_INTERVAL(): any;
    expr(): any;
    interval_item(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Interval_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Interval_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Interval_itemContext;
    T_DAY(): any;
    T_DAYS(): any;
    T_MICROSECOND(): any;
    T_MICROSECONDS(): any;
    T_SECOND(): any;
    T_SECONDS(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_concatContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_concatContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_concatContext;
    expr_concat_item(i: any): any;
    T_PIPE(i: any): any;
    T_CONCAT(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_concat_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_concat_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_concat_itemContext;
    T_OPEN_P(): any;
    expr(): any;
    T_CLOSE_P(): any;
    expr_case(): any;
    expr_agg_window_func(): any;
    expr_spec_func(): any;
    expr_func(): any;
    expr_atom(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_caseContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_caseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_caseContext;
    expr_case_simple(): any;
    expr_case_searched(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_case_simpleContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_case_simpleContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_case_simpleContext;
    T_CASE(): any;
    expr(i: any): any;
    T_END(): any;
    T_WHEN(i: any): any;
    T_THEN(i: any): any;
    T_ELSE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_case_searchedContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_case_searchedContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_case_searchedContext;
    T_CASE(): any;
    T_END(): any;
    T_WHEN(i: any): any;
    bool_expr(i: any): any;
    T_THEN(i: any): any;
    expr(i: any): any;
    T_ELSE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_cursor_attributeContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_cursor_attributeContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_cursor_attributeContext;
    ident(): any;
    T_PRECENT(): any;
    T_ISOPEN(): any;
    T_FOUND(): any;
    T_NOTFOUND(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_agg_window_funcContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_agg_window_funcContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_agg_window_funcContext;
    T_AVG(): any;
    T_OPEN_P(): any;
    expr(i: any): any;
    T_CLOSE_P(): any;
    expr_func_all_distinct(): any;
    expr_func_over_clause(): any;
    T_COUNT(): any;
    T_MUL(): any;
    T_COUNT_BIG(): any;
    T_CUME_DIST(): any;
    T_DENSE_RANK(): any;
    T_FIRST_VALUE(): any;
    T_LAG(): any;
    T_COMMA(i: any): any;
    T_LAST_VALUE(): any;
    T_LEAD(): any;
    T_MAX(): any;
    T_MIN(): any;
    T_RANK(): any;
    T_ROW_NUMBER(): any;
    T_STDEV(): any;
    T_SUM(): any;
    T_VAR(): any;
    T_VARIANCE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_func_all_distinctContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_func_all_distinctContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_func_all_distinctContext;
    T_ALL(): any;
    T_DISTINCT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_func_over_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_func_over_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_func_over_clauseContext;
    T_OVER(): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    expr_func_partition_by_clause(): any;
    order_by_clause(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_func_partition_by_clauseContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_func_partition_by_clauseContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_func_partition_by_clauseContext;
    T_PARTITION(): any;
    T_BY(): any;
    expr(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_spec_funcContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_spec_funcContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_spec_funcContext;
    T_ACTIVITY_COUNT(): any;
    T_CAST(): any;
    T_OPEN_P(): any;
    expr(i: any): any;
    T_AS(): any;
    dtype(): any;
    T_CLOSE_P(): any;
    dtype_len(): any;
    T_COUNT(): any;
    T_MUL(): any;
    T_CURRENT_DATE(): any;
    T_CURRENT(): any;
    T_DATE(): any;
    T_CURRENT_TIMESTAMP(): any;
    T_TIMESTAMP(): any;
    T_CURRENT_USER(): any;
    T_USER(): any;
    T_MAX_PART_STRING(): any;
    T_COMMA(i: any): any;
    T_EQUAL(i: any): any;
    T_MIN_PART_STRING(): any;
    T_MAX_PART_INT(): any;
    T_MIN_PART_INT(): any;
    T_MAX_PART_DATE(): any;
    T_MIN_PART_DATE(): any;
    T_PART_COUNT(): any;
    T_PART_LOC(): any;
    T_TRIM(): any;
    T_SUBSTRING(): any;
    T_FROM(): any;
    T_FOR(): any;
    T_SYSDATE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_funcContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_funcContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_funcContext;
    ident(): any;
    T_OPEN_P(): any;
    T_CLOSE_P(): any;
    expr_func_params(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_func_paramsContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_func_paramsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_func_paramsContext;
    func_param(i: any): any;
    T_COMMA(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Func_paramContext(parser: any, parent: any, invokingState: any): this;
declare class Func_paramContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Func_paramContext;
    expr(): any;
    ident(): any;
    T_EQUAL(): any;
    T_GREATER(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_selectContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_selectContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_selectContext;
    select_stmt(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Expr_fileContext(parser: any, parent: any, invokingState: any): this;
declare class Expr_fileContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Expr_fileContext;
    file_name(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function HiveContext(parser: any, parent: any, invokingState: any): this;
declare class HiveContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof HiveContext;
    T_HIVE(): any;
    hive_item(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Hive_itemContext(parser: any, parent: any, invokingState: any): this;
declare class Hive_itemContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Hive_itemContext;
    T_SUB(): any;
    ident(): any;
    expr(): any;
    L_ID(): any;
    T_EQUAL(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function HostContext(parser: any, parent: any, invokingState: any): this;
declare class HostContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof HostContext;
    T_NOTE(): any;
    host_cmd(): any;
    T_SEMICOLON(): any;
    host_stmt(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Host_cmdContext(parser: any, parent: any, invokingState: any): this;
declare class Host_cmdContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Host_cmdContext;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Host_stmtContext(parser: any, parent: any, invokingState: any): this;
declare class Host_stmtContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Host_stmtContext;
    T_HOST(): any;
    expr(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function File_nameContext(parser: any, parent: any, invokingState: any): this;
declare class File_nameContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof File_nameContext;
    L_FILE(): any;
    ident(i: any): any;
    T_DIV(i: any): any;
    T_DOT(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Date_literalContext(parser: any, parent: any, invokingState: any): this;
declare class Date_literalContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Date_literalContext;
    T_DATE(): any;
    string(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Timestamp_literalContext(parser: any, parent: any, invokingState: any): this;
declare class Timestamp_literalContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Timestamp_literalContext;
    T_TIMESTAMP(): any;
    string(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function IdentContext(parser: any, parent: any, invokingState: any): this;
declare class IdentContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof IdentContext;
    L_ID(i: any): any;
    non_reserved_words(i: any): any;
    T_DOT(i: any): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function StringContext(parser: any, parent: any, invokingState: any): this;
declare class StringContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof StringContext;
    copyFrom(ctx: any): void;
}
declare function Int_numberContext(parser: any, parent: any, invokingState: any): this;
declare class Int_numberContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Int_numberContext;
    L_INT(): any;
    T_SUB(): any;
    T_ADD(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Dec_numberContext(parser: any, parent: any, invokingState: any): this;
declare class Dec_numberContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Dec_numberContext;
    L_DEC(): any;
    T_SUB(): any;
    T_ADD(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Bool_literalContext(parser: any, parent: any, invokingState: any): this;
declare class Bool_literalContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Bool_literalContext;
    T_TRUE(): any;
    T_FALSE(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Null_constContext(parser: any, parent: any, invokingState: any): this;
declare class Null_constContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Null_constContext;
    T_NULL(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Non_reserved_wordsContext(parser: any, parent: any, invokingState: any): this;
declare class Non_reserved_wordsContext {
    constructor(parser: any, parent: any, invokingState: any);
    parser: any;
    ruleIndex: number;
    constructor: typeof Non_reserved_wordsContext;
    T_ACTION(): any;
    T_ACTIVITY_COUNT(): any;
    T_ADD2(): any;
    T_ALL(): any;
    T_ALLOCATE(): any;
    T_ALTER(): any;
    T_AND(): any;
    T_ANSI_NULLS(): any;
    T_ANSI_PADDING(): any;
    T_AS(): any;
    T_ASC(): any;
    T_ASSOCIATE(): any;
    T_AT(): any;
    T_AUTO_INCREMENT(): any;
    T_AVG(): any;
    T_BATCHSIZE(): any;
    T_BEGIN(): any;
    T_BETWEEN(): any;
    T_BIGINT(): any;
    T_BINARY_DOUBLE(): any;
    T_BINARY_FLOAT(): any;
    T_BIT(): any;
    T_BODY(): any;
    T_BREAK(): any;
    T_BY(): any;
    T_BYTE(): any;
    T_CALL(): any;
    T_CALLER(): any;
    T_CASCADE(): any;
    T_CASE(): any;
    T_CASESPECIFIC(): any;
    T_CAST(): any;
    T_CHAR(): any;
    T_CHARACTER(): any;
    T_CHARSET(): any;
    T_CLIENT(): any;
    T_CLOSE(): any;
    T_CLUSTERED(): any;
    T_CMP(): any;
    T_COLLECT(): any;
    T_COLLECTION(): any;
    T_COLUMN(): any;
    T_COMMENT(): any;
    T_COMPRESS(): any;
    T_CONSTANT(): any;
    T_COPY(): any;
    T_COMMIT(): any;
    T_CONCAT(): any;
    T_CONDITION(): any;
    T_CONSTRAINT(): any;
    T_CONTINUE(): any;
    T_COUNT(): any;
    T_COUNT_BIG(): any;
    T_CREATE(): any;
    T_CREATION(): any;
    T_CREATOR(): any;
    T_CS(): any;
    T_CUME_DIST(): any;
    T_CURRENT(): any;
    T_CURRENT_DATE(): any;
    T_CURRENT_SCHEMA(): any;
    T_CURRENT_TIMESTAMP(): any;
    T_CURRENT_USER(): any;
    T_CURSOR(): any;
    T_DATA(): any;
    T_DATABASE(): any;
    T_DATE(): any;
    T_DATETIME(): any;
    T_DAY(): any;
    T_DAYS(): any;
    T_DEC(): any;
    T_DECIMAL(): any;
    T_DECLARE(): any;
    T_DEFAULT(): any;
    T_DEFERRED(): any;
    T_DEFINED(): any;
    T_DEFINER(): any;
    T_DEFINITION(): any;
    T_DELETE(): any;
    T_DELIMITED(): any;
    T_DELIMITER(): any;
    T_DENSE_RANK(): any;
    T_DESC(): any;
    T_DESCRIBE(): any;
    T_DIAGNOSTICS(): any;
    T_DIR(): any;
    T_DIRECTORY(): any;
    T_DISTINCT(): any;
    T_DISTRIBUTE(): any;
    T_DO(): any;
    T_DOUBLE(): any;
    T_DROP(): any;
    T_DYNAMIC(): any;
    T_ENABLE(): any;
    T_ENGINE(): any;
    T_ESCAPED(): any;
    T_EXCEPT(): any;
    T_EXEC(): any;
    T_EXECUTE(): any;
    T_EXCEPTION(): any;
    T_EXCLUSIVE(): any;
    T_EXISTS(): any;
    T_EXIT(): any;
    T_FALLBACK(): any;
    T_FALSE(): any;
    T_FETCH(): any;
    T_FIELDS(): any;
    T_FILE(): any;
    T_FILES(): any;
    T_FIRST_VALUE(): any;
    T_FLOAT(): any;
    T_FOR(): any;
    T_FOREIGN(): any;
    T_FORMAT(): any;
    T_FOUND(): any;
    T_FROM(): any;
    T_FULL(): any;
    T_FUNCTION(): any;
    T_GET(): any;
    T_GLOBAL(): any;
    T_GO(): any;
    T_GRANT(): any;
    T_GROUP(): any;
    T_HANDLER(): any;
    T_HASH(): any;
    T_HAVING(): any;
    T_HDFS(): any;
    T_HIVE(): any;
    T_HOST(): any;
    T_IDENTITY(): any;
    T_IF(): any;
    T_IGNORE(): any;
    T_IMMEDIATE(): any;
    T_IN(): any;
    T_INCLUDE(): any;
    T_INDEX(): any;
    T_INITRANS(): any;
    T_INNER(): any;
    T_INOUT(): any;
    T_INSERT(): any;
    T_INT(): any;
    T_INT2(): any;
    T_INT4(): any;
    T_INT8(): any;
    T_INTEGER(): any;
    T_INTERSECT(): any;
    T_INTERVAL(): any;
    T_INTO(): any;
    T_INVOKER(): any;
    T_ITEMS(): any;
    T_IS(): any;
    T_ISOPEN(): any;
    T_JOIN(): any;
    T_KEEP(): any;
    T_KEY(): any;
    T_KEYS(): any;
    T_LAG(): any;
    T_LANGUAGE(): any;
    T_LAST_VALUE(): any;
    T_LEAD(): any;
    T_LEAVE(): any;
    T_LEFT(): any;
    T_LIKE(): any;
    T_LIMIT(): any;
    T_LINES(): any;
    T_LOCAL(): any;
    T_LOCATION(): any;
    T_LOCATOR(): any;
    T_LOCATORS(): any;
    T_LOCKS(): any;
    T_LOG(): any;
    T_LOGGED(): any;
    T_LOGGING(): any;
    T_LOOP(): any;
    T_MAP(): any;
    T_MATCHED(): any;
    T_MAX(): any;
    T_MAXTRANS(): any;
    T_MERGE(): any;
    T_MESSAGE_TEXT(): any;
    T_MICROSECOND(): any;
    T_MICROSECONDS(): any;
    T_MIN(): any;
    T_MULTISET(): any;
    T_NCHAR(): any;
    T_NEW(): any;
    T_NVARCHAR(): any;
    T_NO(): any;
    T_NOCOMPRESS(): any;
    T_NOCOUNT(): any;
    T_NOLOGGING(): any;
    T_NONE(): any;
    T_NOT(): any;
    T_NOTFOUND(): any;
    T_NUMERIC(): any;
    T_NUMBER(): any;
    T_OBJECT(): any;
    T_OFF(): any;
    T_ON(): any;
    T_ONLY(): any;
    T_OPEN(): any;
    T_OR(): any;
    T_ORDER(): any;
    T_OUT(): any;
    T_OUTER(): any;
    T_OVER(): any;
    T_OVERWRITE(): any;
    T_OWNER(): any;
    T_PACKAGE(): any;
    T_PART_COUNT(): any;
    T_PART_LOC(): any;
    T_PARTITION(): any;
    T_PCTFREE(): any;
    T_PCTUSED(): any;
    T_PRECISION(): any;
    T_PRESERVE(): any;
    T_PRIMARY(): any;
    T_PRINT(): any;
    T_PROC(): any;
    T_PROCEDURE(): any;
    T_PWD(): any;
    T_QUALIFY(): any;
    T_QUERY_BAND(): any;
    T_QUIT(): any;
    T_QUOTED_IDENTIFIER(): any;
    T_RAISE(): any;
    T_RANK(): any;
    T_REAL(): any;
    T_REFERENCES(): any;
    T_REGEXP(): any;
    T_RR(): any;
    T_REPLACE(): any;
    T_RESIGNAL(): any;
    T_RESTRICT(): any;
    T_RESULT(): any;
    T_RESULT_SET_LOCATOR(): any;
    T_RETURN(): any;
    T_RETURNS(): any;
    T_REVERSE(): any;
    T_RIGHT(): any;
    T_RLIKE(): any;
    T_RS(): any;
    T_ROLE(): any;
    T_ROLLBACK(): any;
    T_ROW(): any;
    T_ROWS(): any;
    T_ROW_COUNT(): any;
    T_ROW_NUMBER(): any;
    T_SCHEMA(): any;
    T_SECOND(): any;
    T_SECONDS(): any;
    T_SECURITY(): any;
    T_SEGMENT(): any;
    T_SEL(): any;
    T_SELECT(): any;
    T_SESSION(): any;
    T_SESSIONS(): any;
    T_SET(): any;
    T_SETS(): any;
    T_SHARE(): any;
    T_SIGNAL(): any;
    T_SIMPLE_DOUBLE(): any;
    T_SIMPLE_FLOAT(): any;
    T_SMALLDATETIME(): any;
    T_SMALLINT(): any;
    T_SQL(): any;
    T_SQLEXCEPTION(): any;
    T_SQLINSERT(): any;
    T_SQLSTATE(): any;
    T_SQLWARNING(): any;
    T_STATS(): any;
    T_STATISTICS(): any;
    T_STEP(): any;
    T_STDEV(): any;
    T_STORAGE(): any;
    T_STORED(): any;
    T_STRING(): any;
    T_SUBDIR(): any;
    T_SUBSTRING(): any;
    T_SUM(): any;
    T_SUMMARY(): any;
    T_SYSDATE(): any;
    T_SYS_REFCURSOR(): any;
    T_TABLE(): any;
    T_TABLESPACE(): any;
    T_TEMPORARY(): any;
    T_TERMINATED(): any;
    T_TEXTIMAGE_ON(): any;
    T_THEN(): any;
    T_TIMESTAMP(): any;
    T_TITLE(): any;
    T_TO(): any;
    T_TOP(): any;
    T_TRANSACTION(): any;
    T_TRIM(): any;
    T_TRUE(): any;
    T_TRUNCATE(): any;
    T_UNIQUE(): any;
    T_UPDATE(): any;
    T_UR(): any;
    T_USE(): any;
    T_USER(): any;
    T_USING(): any;
    T_VALUE(): any;
    T_VALUES(): any;
    T_VAR(): any;
    T_VARCHAR(): any;
    T_VARCHAR2(): any;
    T_VARYING(): any;
    T_VARIANCE(): any;
    T_VOLATILE(): any;
    T_WHILE(): any;
    T_WITH(): any;
    T_WITHOUT(): any;
    T_WORK(): any;
    T_XACT_ABORT(): any;
    T_XML(): any;
    T_YES(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Double_quotedStringContext(parser: any, ctx: any): this;
declare class Double_quotedStringContext {
    constructor(parser: any, ctx: any);
    constructor: typeof Double_quotedStringContext;
    L_D_STRING(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
declare function Single_quotedStringContext(parser: any, ctx: any): this;
declare class Single_quotedStringContext {
    constructor(parser: any, ctx: any);
    constructor: typeof Single_quotedStringContext;
    L_S_STRING(): any;
    enterRule(listener: any): void;
    exitRule(listener: any): void;
    accept(visitor: any): any;
}
export {};