export type start = multiple_stmt | cmd_stmt | crud_stmt;

export type cmd_stmt = drop_stmt | create_stmt | truncate_stmt | rename_stmt | call_stmt | use_stmt | alter_stmt | set_stmt | lock_stmt;

export type create_stmt = create_table_stmt | create_constraint_trigger | create_extension_stmt | create_index_stmt;

export type alter_stmt = alter_table_stmt;

export type crud_stmt = union_stmt | update_stmt | replace_insert_stmt | insert_no_columns_stmt | delete_stmt | cmd_stmt | proc_stmts;

export type AstStatement<T> = T;

export type multiple_stmt = AstStatement<crud_stmt[]>;

export interface union_stmt_node extends select_stmt_node {

_next: union_stmt_node;

union: 'union' | 'union all';

}

export type union_stmt = AstStatement<union_stmt_node>;

export type nameOrLiteral = literal_string | { type: 'same', value: string; };

export type create_extension_stmt = {

};

export type create_table_stmt_node = create_table_stmt_node_simple | create_table_stmt_node_like;

export interface create_table_stmt_node_base {

}

export interface create_table_stmt_node_simple extends create_table_stmt_node_base{

}

export interface create_table_stmt_node_like extends create_table_stmt_node_base{

like: create_like_table;

}

export type create_table_stmt = AstStatement<create_table_stmt_node> | AstStatement<create_table_stmt_node>;;

export interface create_index_stmt_node {

}

export type create_index_stmt = AstStatement<create_index_stmt_node>;

export type column_order_list = column_order[];

export type column_order = {

};

export type create_like_table_simple = { type: 'like'; table: table_ref_list; };

export type create_like_table = create_like_table_simple | create_like_table_simple & { parentheses?: boolean; };

export type create_table_definition = create_definition[];

export type create_definition = create_column_definition | create_index_definition | create_fulltext_spatial_index_definition | create_constraint_definition;

export type create_column_definition = {

};

export type column_constraint = { nullable: literal_null | literal_not_null; default_val: default_expr; };

export type collate_expr = { type: 'collate'; value: ident; };

export type column_format = { type: 'column_format'; value: 'fixed' | 'dynamic' | 'default'; };

export type storage = { type: 'storage'; value: 'disk' | 'memory' };

export type default_expr = { type: 'default'; value: literal | expr; };

export interface drop_stmt_node {

}

export type drop_stmt = AstStatement<drop_stmt_node>;

export interface truncate_stmt_node {

}

export type truncate_stmt = AstStatement<truncate_stmt_node>;

export interface use_stmt_node {

type: 'use';

db: ident;

}

export type use_stmt = AstStatement<use_stmt_node>;

export interface alter_table_stmt_node {

}

export type alter_table_stmt = AstStatement<alter_table_stmt_node>;

export type alter_action_list = alter_action[];

export type alter_action = ALTER_ADD_COLUMN | ALTER_DROP_COLUMN | ALTER_ADD_INDEX_OR_KEY | ALTER_ADD_FULLETXT_SPARITAL_INDEX | ALTER_RENAME_TABLE | ALTER_ALGORITHM | ALTER_LOCK;

export type ALTER_ADD_COLUMN = {

} & create_column_definition;;

export type ALTER_DROP_COLUMN = {

};

export type ALTER_ADD_INDEX_OR_KEY = {

action: 'add';

type: 'alter';

} & create_index_definition;

export type ALTER_RENAME_TABLE = {

};

export type ALTER_ALGORITHM = {

};

export type ALTER_LOCK = {

};

export type create_index_definition = {

};

export type create_fulltext_spatial_index_definition = {

};

export type create_constraint_definition = create_constraint_primary | create_constraint_unique | create_constraint_foreign;

export type constraint_name = { keyword: 'constraint'; constraint: ident; };

export type create_constraint_primary = {

};

export type create_constraint_unique = {

};

export type create_constraint_foreign = {

};

export type reference_definition = {

};

export type on_reference = { type: 'on delete' | 'on update'; value: reference_option; };

export type reference_option = 'restrict' | 'cascade' | 'set null' | 'no action' | 'set default';

export type create_constraint_trigger = {

};

export type trigger_event = { keyword: 'insert' | 'delete' | 'truncate' } | { keyword: 'update'; args?: { keyword: 'of', columns: column_ref_list; }};

export type trigger_event_list = trigger_event[];;

export type trigger_deferrable = { keyword: 'deferrable' | 'not deferrable'; args: 'initially immediate' | 'initially deferred' };

export type trigger_for_row = { keyword: 'for' | 'for each'; args: 'row' | 'statement' };

export type trigger_when = { type: 'when'; cond: expr; parentheses: true; };

export type table_options = table_option[];

export type table_option = {

} | { keyword: 'connection' | 'comment'; symbol: '='; value: string; } | { keyword: 'compression'; symbol: '='; value: "'ZLIB'" | "'LZ4'" | "'NONE'" } | { keyword: 'engine'; symbol: '='; value: string; };

export type ALTER_ADD_FULLETXT_SPARITAL_INDEX = create_fulltext_spatial_index_definition & { action: 'add'; type: 'alter' };

export interface rename_stmt_node {

type: 'rename';

table: table_to_list;

}

export type rename_stmt = AstStatement<rename_stmt_node>;

export interface set_stmt_node {

type: 'set';

expr: assign_stmt & { keyword?: 'GLOBAL' | 'SESSION' | 'LOCAL' | 'PERSIST' | 'PERSIST_ONLY'; };

}

export type set_stmt = AstStatement<set_stmt_node>;

export type lock_mode = { mode: string; };

export interface lock_stmt_node {

}

export type lock_stmt = AstStatement<lock_stmt_node>;

export interface call_stmt_node {

type: 'call';

expr: proc_func_call;

}

export type call_stmt = AstStatement<call_stmt_node>;

export interface select_stmt_node extends select_stmt_nake {

parentheses_symbol: true;

}

export type select_stmt = select_stmt_nake | select_stmt_node;

export type with_clause = cte_definition[] | [cte_definition & {recursive: true; }];

export type cte_definition = { name: ident_name; stmt: union_stmt; columns?: cte_column_definition; };

export type cte_column_definition = column[];

export type select_stmt_nake = {

};

export type option_clause = query_option[];

export type query_option = 'SQL_CALC_FOUND_ROWS'| 'SQL_CACHE'| 'SQL_NO_CACHE'| 'SQL_BIG_RESULT'| 'SQL_SMALL_RESULT'| 'SQL_BUFFER_RESULT';

export type column_clause = 'ALL' | '*' | column_list_item[] | column_list_item[];

export type column_list_item = { type: 'cast'; expr: expr; symbol: '::'; target: data_type; as?: null; } | { type: 'star_ref'; expr: column_ref; as: null; } | { type: 'expr'; expr: expr; as?: alias_clause; };

export type alias_clause = alias_ident | ident;

export type from_clause = table_ref_list;

export type table_to_list = table_to_item[];

export type table_to_item = table_name[];

export type index_type = { keyword: 'using'; type: 'btree' | 'hash' | 'gist' | 'gin' };

export type index_options_list = index_option[];

export type index_options = index_option[];

export type index_option = { type: 'key_block_size'; symbol: '='; expr: number; } | { type: ident_name; symbol: '='; expr: number | {type: 'origin'; value: ident; }; } | index_type | { type: 'with parser'; expr: ident_name } | { type: 'visible'; expr: 'visible' } | { type: 'invisible'; expr: 'invisible' } | keyword_comment;

export type table_ref_list = [table_base, ...table_ref[]];

export type table_ref = table_base | table_join;

export type table_join = table_base & {join: join_op; using: ident_name[]; } | table_base & {join: join_op; on?: on_clause; } | {

};

export type table_base = { type: 'dual' } | table_name & { as?: alias_clause; } | { expr: union_stmt; as?: alias_clause; };

export type join_op = 'LEFT JOIN' | 'RIGHT JOIN' | 'FULL JOIN' | 'INNER JOIN';

export type table_name = { db?: ident; table: ident | '*'; };

export type on_clause = expr;

export type where_clause = expr;

export type group_by_clause = expr_list['value'];

export type column_ref_list = column_ref[];

export type having_clause = expr;

export type order_by_clause = order_by_list;

export type order_by_list = order_by_element[];

export type order_by_element = { expr: expr; type: 'ASC' | 'DESC'; };

export type number_or_param = literal_numeric | param;

export type limit_clause = { separator: 'offset' | ''; value: [number_or_param | { type: 'origin', value: 'all' }, number_or_param?] };

export interface update_stmt_node {

}

export type update_stmt = AstStatement<update_stmt_node>;

export interface table_ref_addition extends table_name {

addition: true;

as?: alias_clause;

}

export interface delete_stmt_node {

}

export type delete_stmt = AstStatement<delete_stmt_node>;

export type set_list = set_item[];

export type set_item = { column: ident; value: additive_expr; table?: ident;};

export type returning_stmt = { type: 'returning'; columns: column_ref_list; };

export type insert_value_clause = value_clause | select_stmt_nake;

export type insert_partition = ident_name[] | value_item;

export interface replace_insert_stmt_node {

}

export type replace_insert_stmt = AstStatement<replace_insert_stmt_node>;

export type insert_no_columns_stmt = AstStatement<replace_insert_stmt_node>;

export type replace_insert = 'insert' | 'replace';

export type value_clause = value_list;

export type value_list = value_item[];

export type value_item = expr_list;

export type expr_list = { type: 'expr_list'; value: expr[] };

export type interval_expr = { type: 'interval', expr: expr; unit: interval_unit; };

export type case_expr = {

};

export type case_when_then = { type: 'when'; cond: expr; result: expr; };

export type case_else = { type: 'else'; condition?: never; result: expr; };

export type expr = logic_operator_expr | unary_expr | or_expr | select_stmt;

export type BINARY_OPERATORS = LOGIC_OPERATOR | 'OR' | 'AND' | multiplicative_operator | additive_operator

| '@>' | '<@' | OPERATOR_CONCATENATION | DOUBLE_WELL_ARROW | WELL_ARROW | '?' | '?|' | '?&' | '#-'

export interface binary_expr {

}

export type logic_operator_expr = binary_expr;

export type UNARY_OPERATORS = '+' | '-' | 'EXISTS' | 'NOT EXISTS' | 'NULL'

export type unary_expr = {

};

export type or_expr = binary_expr;

export type and_expr = binary_expr;

export type not_expr = comparison_expr | exists_expr | unary_expr;

export type comparison_expr = binary_expr;

export type exists_expr = unary_expr;

export type exists_op = 'NOT EXISTS' | KW_EXISTS;

export type comparison_op_right = arithmetic_op_right | in_op_right | between_op_right | is_op_right | like_op_right | jsonb_op_right;

export type arithmetic_op_right = { type: 'arithmetic'; tail: any };

export type arithmetic_comparison_operator = ">=" | ">" | "<=" | "<>" | "<" | "=" | "!=";

export type is_op_right = { op: 'IS'; right: additive_expr; } | { type: 'origin'; value: string; } | { type: 'IS NOT'; right: additive_expr; };

export type between_op_right = { op: 'BETWEEN' | 'NOT BETWEEN'; right: { type: 'expr_list'; value: [expr, expr] } };

export type between_or_not_between_op = 'NOT BETWEEN' | KW_BETWEEN;

export type like_op = 'LIKE' | KW_LIKE;

export type in_op = 'NOT IN' | KW_IN;

export type like_op_right = { op: like_op; right: comparison_expr};

export type in_op_right = {op: in_op; right: expr_list | var_decl | literal_string; };

export type jsonb_op_right = { op: string; right: expr };

export type additive_expr = binary_expr;

export type additive_operator = "+" | "-";

export type multiplicative_expr = binary_expr;

export type multiplicative_operator = "*" | "/" | "%";

export type primary = cast_expr | literal | aggr_func | func_call | case_expr | interval_expr | column_ref | param | expr | expr_list | var_decl | { type: 'origin'; value: string; };

export type column_ref = {

};

export type column_list = column[];

export type ident = string;

export type alias_ident = string;

export type quoted_ident = double_quoted_ident | single_quoted_ident | backticks_quoted_ident;

export type double_quoted_ident = string;

export type single_quoted_ident = string;

export type backticks_quoted_ident = string;

export type column = string | quoted_ident;

export type column_name = string;

export type ident_name = string;

type ident_start = never;

type ident_part = never;

type column_part = never;

export type param = { type: 'param'; value: ident_name };

export type aggr_func = aggr_fun_count | aggr_fun_smma;

export type aggr_fun_smma = { type: 'aggr_func'; name: 'SUM' | 'MAX' | 'MIN' | 'AVG'; args: { expr: additive_expr } };

type KW_SUM_MAX_MIN_AVG = never;

export type aggr_fun_count = { type: 'aggr_func'; name: 'COUNT'; args:count_arg; };

export type count_arg = { expr: star_expr } | { distinct: 'DISTINCT'; expr: column_ref; };

export type star_expr = { type: 'star'; value: '*' };

export type func_call = { type: 'function'; name: string; args: expr_list; } | extract_func;

export type extract_filed = "CENTURY" | "DAY" | "DECADE" | "DOW" | "DOY" | "EPOCH" | "HOUR" | "ISODOW" | "ISOYEAR" | "MICROSECONDS" | "MILLENNIUM" | "MILLISECONDS" | "MINUTE" | "MONTH" | "QUARTER" | "SECOND" | "TIMEZONE" | "TIMEZONE_HOUR" | "TIMEZONE_MINUTE" | "WEEK" | 'string';

export type extract_func = { type: 'extract'; args: { field: extract_filed; cast_type: 'TIMESTAMP' | 'INTERVAL' | 'TIME'; source: expr; }};

export type scalar_func = KW_CURRENT_DATE | KW_CURRENT_TIME | KW_CURRENT_TIMESTAMP | KW_CURRENT_USER | KW_USER | KW_SESSION_USER | KW_SYSTEM_USER;

export type cast_expr = {

};

export type signedness = KW_SIGNED | KW_UNSIGNED;

export type literal = literal_string | literal_numeric | literal_bool | literal_null | literal_datetime;

export type literal_list = literal[];

export type literal_null = { type: 'null'; value: null };

export type literal_not_null = { type: 'not null'; value: 'not null' };

export type literal_bool = { type: 'bool', value: true } | { type: 'bool', value: false };

export type literal_string = { type: 'single_quote_string'; value: string; } | { type: 'string'; value: string; };

export type literal_datetime = { type: 'TIME' | 'DATE' | 'TIMESTAMP' | 'DATETIME', value: string } | { type: 'origin'; value: string; };

export type single_quote_char = string;

export type single_char = string;

export type escape_char = string;

export type line_terminator = string;

export type literal_numeric = number | { type: 'bigint'; value: string; };

export type int = string;

export type frac = string;

export type exp = string;

export type digits = string;

export type digit = string;

export type hexDigit = string;

export type e = string;

type KW_NULL = never;

type KW_DEFAULT = never;

type KW_NOT_NULL = never;

type KW_TRUE = never;

type KW_TO = never;

type KW_FALSE = never;

type KW_SHOW = never;

type KW_DROP = never;

type KW_USE = never;

type KW_ALTER = never;

type KW_SELECT = never;

type KW_UPDATE = never;

type KW_CREATE = never;

type KW_TEMPORARY = never;

type KW_IF_NOT_EXISTS = never;

type KW_DELETE = never;

type KW_INSERT = never;

type KW_RECURSIVE = never;

type KW_REPLACE = never;

type KW_RETURNING = never;

type KW_RENAME = never;

type KW_IGNORE = never;

type KW_EXPLAIN = never;

type KW_PARTITION = never;

type KW_INTO = never;

type KW_FROM = never;

type KW_SET = never;

type KW_LOCK = never;

type KW_AS = never;

type KW_TABLE = never;

type KW_TABLESPACE = never;

type KW_COLLATE = never;

type KW_ON = never;

type KW_LEFT = never;

type KW_RIGHT = never;

type KW_FULL = never;

type KW_INNER = never;

type KW_JOIN = never;

type KW_OUTER = never;

type KW_UNION = never;

type KW_VALUES = never;

type KW_USING = never;

type KW_WHERE = never;

type KW_WITH = never;

type KW_GROUP = never;

type KW_BY = never;

type KW_ORDER = never;

type KW_HAVING = never;

type KW_LIMIT = never;

type KW_OFFSET = never;

type KW_ASC = never;

type KW_DESC = never;

type KW_ALL = never;

type KW_DISTINCT = never;

type KW_BETWEEN = never;

type KW_IN = never;

type KW_IS = never;

type KW_LIKE = never;

type KW_EXISTS = never;

type KW_NOT = never;

type KW_AND = never;

type KW_OR = never;

type KW_COUNT = never;

type KW_MAX = never;

type KW_MIN = never;

type KW_SUM = never;

type KW_AVG = never;

type KW_EXTRACT = never;

type KW_CALL = never;

type KW_CASE = never;

type KW_WHEN = never;

type KW_THEN = never;

type KW_ELSE = never;

type KW_END = never;

type KW_CAST = never;

type KW_BOOL = never;

type KW_BOOLEAN = never;

type KW_CHAR = never;

type KW_VARCHAR = never;

type KW_NUMERIC = never;

type KW_DECIMAL = never;

type KW_SIGNED = never;

type KW_UNSIGNED = never;

type KW_INT = never;

type KW_ZEROFILL = never;

type KW_INTEGER = never;

type KW_JSON = never;

type KW_JSONB = never;

type KW_GEOMETRY = never;

type KW_SMALLINT = never;

type KW_TINYINT = never;

type KW_TINYTEXT = never;

type KW_TEXT = never;

type KW_MEDIUMTEXT = never;

type KW_LONGTEXT = never;

type KW_BIGINT = never;

type KW_FLOAT = never;

type KW_DOUBLE = never;

type KW_DATE = never;

type KW_DATETIME = never;

type KW_TIME = never;

type KW_TIMESTAMP = never;

type KW_TRUNCATE = never;

type KW_USER = never;

type KW_UUID = never;

type KW_CURRENT_DATE = never;