@foul11/awesome-db 1.1.0

package/dist/SQLParser.d.ts

@@ -0,0 +1,1394 @@
+/** @param {string | TemplateStringsArray} str */
+export function sqlv(str: string | TemplateStringsArray): string;
+export class SQLParser {
+    /**
+     * @typedef {string | number | null} sqlite_value
+     *
+     * @typedef {{
+     *  scheme_parts: string[],
+     *  name: string,
+     * }} sqlite_schema
+     *
+     * @typedef {{
+     *   name: string,
+     *   as: string?,
+     *   sort: 'ASC' | 'DESC' | null,
+     * }} sqlite_column
+     *
+     * @typedef {{
+     *  type: 'PRAGMA',
+     *  name: sqlite_schema,
+     *  value: sqlite_value,
+     * }} sqlite_PRAGMA
+     *
+     * @typedef {{
+     *  type: 'SAVEPOINT',
+     *  savepoint_name: string?,
+     * }} sqlite_SAVEPOINT
+     *
+     * @typedef {{
+     *  type: 'RELEASE',
+     *  savepoint_name: string?,
+     * }} sqlite_RELEASE
+     *
+     * @typedef {{
+     *  type: 'SELECT',
+     *  distinct: boolean,
+     *  columns: Exclude<sqlite_column, 'sort'>[],
+     *  from: sqlite_schema[],
+     *  where: string?,
+     *  group_by: string?,
+     *  order_by: string?,
+     *  limit: number?,
+     *  offset: number?,
+     * }} sqlite_SELECT
+     *
+     * @typedef {{
+     *  table: sqlite_schema,
+     *  columns: string[],
+     *  constraints: string?,
+     * }} sqlite_references
+     *
+     * @typedef {'TEXT' | 'INTEGER' | 'REAL' | 'BLOB' | 'DATETIME'} sqlite_types
+     *
+     * @typedef {{
+     *  name: string,
+     *  type: sqlite_types,
+     *  primary: boolean,
+     *  auto_increment: boolean,
+     *  not_null: boolean,
+     *  unique: boolean,
+     *  default: sqlite_value,
+     *  references: sqlite_references?,
+     * }} sqlite_column_def
+     *
+     * @typedef {Omit<Omit<sqlite_column_def, 'name'>, 'type'>} sqlite_constraint
+     *
+     * @typedef {{
+     *  type: 'CREATE_TABLE',
+     *  table: sqlite_schema,
+     *  if_not_exists: boolean,
+     *  columns: sqlite_column_def[],
+     * }} sqlite_CREATE_TABLE
+     *
+     * @typedef {{
+     *  type: 'CREATE_INDEX',
+     *  name: sqlite_schema,
+     *  table_name: string,
+     *  if_not_exists: boolean,
+     *  unique: boolean,
+     *  columns: Omit<sqlite_column, 'as'>[],
+     * }} sqlite_CREATE_INDEX
+     *
+     * @typedef {{
+     *  type: 'VALUES',
+     *  values: (number | string)[],
+     * }} sqlite_VALUES
+     *
+     * @typedef {{
+     *  type: 'INSERT',
+     *  table: sqlite_schema,
+     *  columns: Omit<Omit<sqlite_column, 'as'>, 'sort'>[],
+     *  expr: sqlite_VALUES | sqlite_SELECT,
+     * }} sqlite_INSERT
+     *
+     * @typedef {{
+     *  type: 'DROP_TABLE',
+     *  table: sqlite_schema,
+     *  if_not_exists: boolean,
+     * }} sqlite_DROP_TABLE
+     *
+     * @typedef {{
+     *  type: 'DROP_INDEX',
+     *  name: sqlite_schema,
+     *  if_not_exists: boolean,
+     * }} sqlite_DROP_INDEX
+     *
+     * @typedef {{
+     *  type: 'ALTER_RENAME_TO',
+     *  table: sqlite_schema,
+     *  to: string,
+     * }} sqlite_ALTER_RENAME_TO
+     *
+     * @typedef {{
+     *  type: 'ALTER_RENAME_COLUMN',
+     *  table: sqlite_schema,
+     *  from: string,
+     *  to: string,
+     * }} sqlite_ALTER_RENAME_COLUMN
+     *
+     * @typedef {{
+     *  type: 'ALTER_ADD',
+     *  table: sqlite_schema,
+     *  column: sqlite_column_def,
+     * }} sqlite_ALTER_ADD
+     *
+     * @typedef {{
+     *  type: 'ALTER_DROP',
+     *  table: sqlite_schema,
+     *  column_name: string,
+     * }} sqlite_ALTER_DROP
+     *
+     * @typedef {sqlite_PRAGMA              |
+     *           sqlite_SAVEPOINT           |
+     *           sqlite_RELEASE             |
+     *           sqlite_SELECT              |
+     *           sqlite_CREATE_TABLE        |
+     *           sqlite_CREATE_INDEX        |
+     *           sqlite_VALUES              |
+     *           sqlite_INSERT              |
+     *           sqlite_DROP_TABLE          |
+     *           sqlite_DROP_INDEX          |
+     *           sqlite_ALTER_RENAME_TO     |
+     *           sqlite_ALTER_RENAME_COLUMN |
+     *           sqlite_ALTER_ADD           |
+     *           sqlite_ALTER_DROP
+     * } sqlite_EXPRS
+     */
+    /**
+     * @param {string} sql
+     * @param {string} char
+     */
+    static splitQStrByChar(sql: string, char: string): string[];
+    /**
+     * @param {string} input
+     * @returns {sqlite_schema}
+     */
+    static sqliteSchema(input: string): {
+        scheme_parts: string[];
+        name: string;
+    };
+    /** @param {string | null | undefined} input */
+    static sqliteName(input: string | null | undefined): string;
+    /**
+     * @param {string} input
+     * @returns {sqlite_column[]}
+     */
+    static sqliteColumns(input: string): {
+        name: string;
+        as: string | null;
+        sort: "ASC" | "DESC" | null;
+    }[];
+    /**
+     * @param {RegExp} rgx
+     * @param {string} input
+     */
+    static matchAllGroups(rgx: RegExp, input: string): {
+        groups: Record<string, string | undefined>;
+    };
+    /**
+     * @param {string} input
+     * @returns {sqlite_column_def[]}
+     */
+    static sqliteColumnsDef(input: string): {
+        name: string;
+        type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+        primary: boolean;
+        auto_increment: boolean;
+        not_null: boolean;
+        unique: boolean;
+        default: string | number | null;
+        references: {
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            columns: string[];
+            constraints: string | null;
+        } | null;
+    }[];
+    /**
+     * @param {string | null | undefined} input
+     * @returns {sqlite_value}
+     */
+    static sqliteValue(input: string | null | undefined): string | number | null;
+    /** @param {string | null | undefined} str */
+    static strOrNull(str: string | null | undefined): string | null;
+    /** @param {string | null | undefined} str */
+    static intOrNull(str: string | null | undefined): number | null;
+    static regex: {
+        PRAGMA: RegExp;
+        SAVEPOINT: RegExp;
+        RELEASE: RegExp;
+        SELECT: RegExp;
+        CREATE_TABLE: RegExp;
+        CREATE_INDEX: RegExp;
+        VALUES: RegExp;
+        INSERT: RegExp;
+        DROP: RegExp;
+        ALTER_TABLE: RegExp;
+        column: RegExp;
+        column_def: RegExp;
+        constraint: RegExp;
+        table_constraint: RegExp;
+    };
+    /** @param {string} sql */
+    static parse(sql: string): ({
+        type: "PRAGMA";
+        name: {
+            scheme_parts: string[];
+            name: string;
+        };
+        value: string | number | null;
+    } | {
+        type: "SAVEPOINT";
+        savepoint_name: string | null;
+    } | {
+        type: "RELEASE";
+        savepoint_name: string | null;
+    } | {
+        type: "SELECT";
+        distinct: boolean;
+        columns: Exclude<{
+            name: string;
+            as: string | null;
+            sort: "ASC" | "DESC" | null;
+        }, "sort">[];
+        from: {
+            scheme_parts: string[];
+            name: string;
+        }[];
+        where: string | null;
+        group_by: string | null;
+        order_by: string | null;
+        limit: number | null;
+        offset: number | null;
+    } | {
+        type: "CREATE_TABLE";
+        table: {
+            scheme_parts: string[];
+            name: string;
+        };
+        if_not_exists: boolean;
+        columns: {
+            name: string;
+            type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+            primary: boolean;
+            auto_increment: boolean;
+            not_null: boolean;
+            unique: boolean;
+            default: string | number | null;
+            references: {
+                table: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                columns: string[];
+                constraints: string | null;
+            } | null;
+        }[];
+    } | {
+        type: "CREATE_INDEX";
+        name: {
+            scheme_parts: string[];
+            name: string;
+        };
+        table_name: string;
+        if_not_exists: boolean;
+        unique: boolean;
+        columns: Omit<{
+            name: string;
+            as: string | null;
+            sort: "ASC" | "DESC" | null;
+        }, "as">[];
+    } | {
+        type: "VALUES";
+        values: (number | string)[];
+    } | {
+        type: "INSERT";
+        table: {
+            scheme_parts: string[];
+            name: string;
+        };
+        columns: Omit<Omit<{
+            name: string;
+            as: string | null;
+            sort: "ASC" | "DESC" | null;
+        }, "as">, "sort">[];
+        expr: {
+            type: "VALUES";
+            values: (number | string)[];
+        } | {
+            type: "SELECT";
+            distinct: boolean;
+            columns: Exclude<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "sort">[];
+            from: {
+                scheme_parts: string[];
+                name: string;
+            }[];
+            where: string | null;
+            group_by: string | null;
+            order_by: string | null;
+            limit: number | null;
+            offset: number | null;
+        };
+    } | {
+        type: "DROP_TABLE";
+        table: {
+            scheme_parts: string[];
+            name: string;
+        };
+        if_not_exists: boolean;
+    } | {
+        type: "DROP_INDEX";
+        name: {
+            scheme_parts: string[];
+            name: string;
+        };
+        if_not_exists: boolean;
+    } | {
+        type: "ALTER_RENAME_TO";
+        table: {
+            scheme_parts: string[];
+            name: string;
+        };
+        to: string;
+    } | {
+        type: "ALTER_RENAME_COLUMN";
+        table: {
+            scheme_parts: string[];
+            name: string;
+        };
+        from: string;
+        to: string;
+    } | {
+        type: "ALTER_ADD";
+        table: {
+            scheme_parts: string[];
+            name: string;
+        };
+        column: {
+            name: string;
+            type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+            primary: boolean;
+            auto_increment: boolean;
+            not_null: boolean;
+            unique: boolean;
+            default: string | number | null;
+            references: {
+                table: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                columns: string[];
+                constraints: string | null;
+            } | null;
+        };
+    } | {
+        type: "ALTER_DROP";
+        table: {
+            scheme_parts: string[];
+            name: string;
+        };
+        column_name: string;
+    })[];
+}
+export class SQLiteDebugger {
+    /**
+     * @typedef {number | {
+     *  from: number,
+     *  to: number,
+     * }} sqlited_index
+     *
+     * @typedef {{
+     *  type: 'LINK_SQLITE',
+     *  index: number,
+     *  link: sqlite_EXPRS,
+     *  linked: Map<sqlited_link_logic_sub_type, Set<sqlited_link_logic | sqlited_link_sqlite>>,
+     * }} sqlited_link_sqlite
+     *
+     * @typedef {'SAVE/RELEASE' | 'LINK_TABLE'} sqlited_link_logic_sub_type
+     *
+     * @typedef {{
+     *  type: 'LINK',
+     *  sub_type: sqlited_link_logic_sub_type,
+     *  index: sqlited_index,
+     *  child: (sqlited_link_logic | sqlited_link_sqlite)[],
+     * }} sqlited_link_logic
+     */
+    /**
+     * @param {sqlited_index?} i1
+     * @param {sqlited_index?} i2
+     */
+    static sql_idx_min(i1: (number | {
+        from: number;
+        to: number;
+    }) | null, i2: (number | {
+        from: number;
+        to: number;
+    }) | null): number | null;
+    /**
+     * @param {sqlited_index?} i1
+     * @param {sqlited_index?} i2
+     */
+    static sql_idx_max(i1: (number | {
+        from: number;
+        to: number;
+    }) | null, i2: (number | {
+        from: number;
+        to: number;
+    }) | null): number | null;
+    /**
+     * @param {sqlited_index?} i1
+     * @param {sqlited_index?} i2
+     */
+    static sql_idx_outRange(i1: (number | {
+        from: number;
+        to: number;
+    }) | null, i2: (number | {
+        from: number;
+        to: number;
+    }) | null): boolean | null;
+    /**
+     * @param {sqlited_index?} i1
+     * @param {sqlited_index?} i2
+     */
+    static sql_idx_inRange(i1: (number | {
+        from: number;
+        to: number;
+    }) | null, i2: (number | {
+        from: number;
+        to: number;
+    }) | null): boolean | null;
+    /**
+     * @param {sqlited_index?} i1
+     * @param {sqlited_index?} i2
+     */
+    static sql_idx_invalidRange(i1: (number | {
+        from: number;
+        to: number;
+    }) | null, i2: (number | {
+        from: number;
+        to: number;
+    }) | null): boolean;
+    /** @param {any} db */
+    constructor(db: any);
+    db: any;
+    /**
+     * @param {string} table
+     * @returns {{
+     *  cid: number,
+     *  name: string,
+     *  type: 'INTEGER' | 'REAL' | 'TEXT' | 'BLOB' | 'NUMERIC',
+     *  notnull: boolean,
+     *  dflt_value: string | null,
+     *  pk: boolean,
+     * }[]}
+     */
+    tableInfo(table: string): {
+        cid: number;
+        name: string;
+        type: "INTEGER" | "REAL" | "TEXT" | "BLOB" | "NUMERIC";
+        notnull: boolean;
+        dflt_value: string | null;
+        pk: boolean;
+    }[];
+    /**
+     * @returns {{
+     *  type: 'index' | 'table',
+     *  name: string,
+     *  tbl_name: string,
+     *  rootpage: number,
+     *  sql: string,
+     * }[]}
+     */
+    masterTable(): {
+        type: "index" | "table";
+        name: string;
+        tbl_name: string;
+        rootpage: number;
+        sql: string;
+    }[];
+    /**
+     * @param {sqlited_link_sqlite[]} links
+     * @param {sqlited_link_sqlite} link
+     * @param {sqlited_link_logic_sub_type} sub_type
+     * @param {(link: sqlited_link_sqlite, input: sqlited_link_sqlite) => boolean} predicate
+     * @returns {sqlited_link_logic[]}
+     */
+    link_for_predicate(links: {
+        type: "LINK_SQLITE";
+        index: number;
+        link: {
+            type: "PRAGMA";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            value: string | number | null;
+        } | {
+            type: "SAVEPOINT";
+            savepoint_name: string | null;
+        } | {
+            type: "RELEASE";
+            savepoint_name: string | null;
+        } | {
+            type: "SELECT";
+            distinct: boolean;
+            columns: Exclude<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "sort">[];
+            from: {
+                scheme_parts: string[];
+                name: string;
+            }[];
+            where: string | null;
+            group_by: string | null;
+            order_by: string | null;
+            limit: number | null;
+            offset: number | null;
+        } | {
+            type: "CREATE_TABLE";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+            columns: {
+                name: string;
+                type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                primary: boolean;
+                auto_increment: boolean;
+                not_null: boolean;
+                unique: boolean;
+                default: string | number | null;
+                references: {
+                    table: {
+                        scheme_parts: string[];
+                        name: string;
+                    };
+                    columns: string[];
+                    constraints: string | null;
+                } | null;
+            }[];
+        } | {
+            type: "CREATE_INDEX";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            table_name: string;
+            if_not_exists: boolean;
+            unique: boolean;
+            columns: Omit<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "as">[];
+        } | {
+            type: "VALUES";
+            values: (number | string)[];
+        } | {
+            type: "INSERT";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            columns: Omit<Omit<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "as">, "sort">[];
+            expr: {
+                type: "VALUES";
+                values: (number | string)[];
+            } | {
+                type: "SELECT";
+                distinct: boolean;
+                columns: Exclude<{
+                    name: string;
+                    as: string | null;
+                    sort: "ASC" | "DESC" | null;
+                }, "sort">[];
+                from: {
+                    scheme_parts: string[];
+                    name: string;
+                }[];
+                where: string | null;
+                group_by: string | null;
+                order_by: string | null;
+                limit: number | null;
+                offset: number | null;
+            };
+        } | {
+            type: "DROP_TABLE";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+        } | {
+            type: "DROP_INDEX";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+        } | {
+            type: "ALTER_RENAME_TO";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            to: string;
+        } | {
+            type: "ALTER_RENAME_COLUMN";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            from: string;
+            to: string;
+        } | {
+            type: "ALTER_ADD";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            column: {
+                name: string;
+                type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                primary: boolean;
+                auto_increment: boolean;
+                not_null: boolean;
+                unique: boolean;
+                default: string | number | null;
+                references: {
+                    table: {
+                        scheme_parts: string[];
+                        name: string;
+                    };
+                    columns: string[];
+                    constraints: string | null;
+                } | null;
+            };
+        } | {
+            type: "ALTER_DROP";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            column_name: string;
+        };
+        linked: Map<"SAVE/RELEASE" | "LINK_TABLE", Set<{
+            type: "LINK";
+            sub_type: "SAVE/RELEASE" | "LINK_TABLE";
+            index: number | {
+                from: number;
+                to: number;
+            };
+            child: (/*elided*/ any | /*elided*/ any)[];
+        } | /*elided*/ any>>;
+    }[], link: {
+        type: "LINK_SQLITE";
+        index: number;
+        link: {
+            type: "PRAGMA";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            value: string | number | null;
+        } | {
+            type: "SAVEPOINT";
+            savepoint_name: string | null;
+        } | {
+            type: "RELEASE";
+            savepoint_name: string | null;
+        } | {
+            type: "SELECT";
+            distinct: boolean;
+            columns: Exclude<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "sort">[];
+            from: {
+                scheme_parts: string[];
+                name: string;
+            }[];
+            where: string | null;
+            group_by: string | null;
+            order_by: string | null;
+            limit: number | null;
+            offset: number | null;
+        } | {
+            type: "CREATE_TABLE";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+            columns: {
+                name: string;
+                type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                primary: boolean;
+                auto_increment: boolean;
+                not_null: boolean;
+                unique: boolean;
+                default: string | number | null;
+                references: {
+                    table: {
+                        scheme_parts: string[];
+                        name: string;
+                    };
+                    columns: string[];
+                    constraints: string | null;
+                } | null;
+            }[];
+        } | {
+            type: "CREATE_INDEX";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            table_name: string;
+            if_not_exists: boolean;
+            unique: boolean;
+            columns: Omit<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "as">[];
+        } | {
+            type: "VALUES";
+            values: (number | string)[];
+        } | {
+            type: "INSERT";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            columns: Omit<Omit<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "as">, "sort">[];
+            expr: {
+                type: "VALUES";
+                values: (number | string)[];
+            } | {
+                type: "SELECT";
+                distinct: boolean;
+                columns: Exclude<{
+                    name: string;
+                    as: string | null;
+                    sort: "ASC" | "DESC" | null;
+                }, "sort">[];
+                from: {
+                    scheme_parts: string[];
+                    name: string;
+                }[];
+                where: string | null;
+                group_by: string | null;
+                order_by: string | null;
+                limit: number | null;
+                offset: number | null;
+            };
+        } | {
+            type: "DROP_TABLE";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+        } | {
+            type: "DROP_INDEX";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+        } | {
+            type: "ALTER_RENAME_TO";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            to: string;
+        } | {
+            type: "ALTER_RENAME_COLUMN";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            from: string;
+            to: string;
+        } | {
+            type: "ALTER_ADD";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            column: {
+                name: string;
+                type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                primary: boolean;
+                auto_increment: boolean;
+                not_null: boolean;
+                unique: boolean;
+                default: string | number | null;
+                references: {
+                    table: {
+                        scheme_parts: string[];
+                        name: string;
+                    };
+                    columns: string[];
+                    constraints: string | null;
+                } | null;
+            };
+        } | {
+            type: "ALTER_DROP";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            column_name: string;
+        };
+        linked: Map<"SAVE/RELEASE" | "LINK_TABLE", Set<{
+            type: "LINK";
+            sub_type: "SAVE/RELEASE" | "LINK_TABLE";
+            index: number | {
+                from: number;
+                to: number;
+            };
+            child: (/*elided*/ any | /*elided*/ any)[];
+        } | /*elided*/ any>>;
+    }, sub_type: "SAVE/RELEASE" | "LINK_TABLE", predicate: (link: {
+        type: "LINK_SQLITE";
+        index: number;
+        link: {
+            type: "PRAGMA";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            value: string | number | null;
+        } | {
+            type: "SAVEPOINT";
+            savepoint_name: string | null;
+        } | {
+            type: "RELEASE";
+            savepoint_name: string | null;
+        } | {
+            type: "SELECT";
+            distinct: boolean;
+            columns: Exclude<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "sort">[];
+            from: {
+                scheme_parts: string[];
+                name: string;
+            }[];
+            where: string | null;
+            group_by: string | null;
+            order_by: string | null;
+            limit: number | null;
+            offset: number | null;
+        } | {
+            type: "CREATE_TABLE";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+            columns: {
+                name: string;
+                type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                primary: boolean;
+                auto_increment: boolean;
+                not_null: boolean;
+                unique: boolean;
+                default: string | number | null;
+                references: {
+                    table: {
+                        scheme_parts: string[];
+                        name: string;
+                    };
+                    columns: string[];
+                    constraints: string | null;
+                } | null;
+            }[];
+        } | {
+            type: "CREATE_INDEX";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            table_name: string;
+            if_not_exists: boolean;
+            unique: boolean;
+            columns: Omit<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "as">[];
+        } | {
+            type: "VALUES";
+            values: (number | string)[];
+        } | {
+            type: "INSERT";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            columns: Omit<Omit<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "as">, "sort">[];
+            expr: {
+                type: "VALUES";
+                values: (number | string)[];
+            } | {
+                type: "SELECT";
+                distinct: boolean;
+                columns: Exclude<{
+                    name: string;
+                    as: string | null;
+                    sort: "ASC" | "DESC" | null;
+                }, "sort">[];
+                from: {
+                    scheme_parts: string[];
+                    name: string;
+                }[];
+                where: string | null;
+                group_by: string | null;
+                order_by: string | null;
+                limit: number | null;
+                offset: number | null;
+            };
+        } | {
+            type: "DROP_TABLE";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+        } | {
+            type: "DROP_INDEX";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+        } | {
+            type: "ALTER_RENAME_TO";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            to: string;
+        } | {
+            type: "ALTER_RENAME_COLUMN";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            from: string;
+            to: string;
+        } | {
+            type: "ALTER_ADD";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            column: {
+                name: string;
+                type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                primary: boolean;
+                auto_increment: boolean;
+                not_null: boolean;
+                unique: boolean;
+                default: string | number | null;
+                references: {
+                    table: {
+                        scheme_parts: string[];
+                        name: string;
+                    };
+                    columns: string[];
+                    constraints: string | null;
+                } | null;
+            };
+        } | {
+            type: "ALTER_DROP";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            column_name: string;
+        };
+        linked: Map<"SAVE/RELEASE" | "LINK_TABLE", Set<{
+            type: "LINK";
+            sub_type: "SAVE/RELEASE" | "LINK_TABLE";
+            index: number | {
+                from: number;
+                to: number;
+            };
+            child: (/*elided*/ any | /*elided*/ any)[];
+        } | /*elided*/ any>>;
+    }, input: {
+        type: "LINK_SQLITE";
+        index: number;
+        link: {
+            type: "PRAGMA";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            value: string | number | null;
+        } | {
+            type: "SAVEPOINT";
+            savepoint_name: string | null;
+        } | {
+            type: "RELEASE";
+            savepoint_name: string | null;
+        } | {
+            type: "SELECT";
+            distinct: boolean;
+            columns: Exclude<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "sort">[];
+            from: {
+                scheme_parts: string[];
+                name: string;
+            }[];
+            where: string | null;
+            group_by: string | null;
+            order_by: string | null;
+            limit: number | null;
+            offset: number | null;
+        } | {
+            type: "CREATE_TABLE";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+            columns: {
+                name: string;
+                type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                primary: boolean;
+                auto_increment: boolean;
+                not_null: boolean;
+                unique: boolean;
+                default: string | number | null;
+                references: {
+                    table: {
+                        scheme_parts: string[];
+                        name: string;
+                    };
+                    columns: string[];
+                    constraints: string | null;
+                } | null;
+            }[];
+        } | {
+            type: "CREATE_INDEX";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            table_name: string;
+            if_not_exists: boolean;
+            unique: boolean;
+            columns: Omit<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "as">[];
+        } | {
+            type: "VALUES";
+            values: (number | string)[];
+        } | {
+            type: "INSERT";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            columns: Omit<Omit<{
+                name: string;
+                as: string | null;
+                sort: "ASC" | "DESC" | null;
+            }, "as">, "sort">[];
+            expr: {
+                type: "VALUES";
+                values: (number | string)[];
+            } | {
+                type: "SELECT";
+                distinct: boolean;
+                columns: Exclude<{
+                    name: string;
+                    as: string | null;
+                    sort: "ASC" | "DESC" | null;
+                }, "sort">[];
+                from: {
+                    scheme_parts: string[];
+                    name: string;
+                }[];
+                where: string | null;
+                group_by: string | null;
+                order_by: string | null;
+                limit: number | null;
+                offset: number | null;
+            };
+        } | {
+            type: "DROP_TABLE";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+        } | {
+            type: "DROP_INDEX";
+            name: {
+                scheme_parts: string[];
+                name: string;
+            };
+            if_not_exists: boolean;
+        } | {
+            type: "ALTER_RENAME_TO";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            to: string;
+        } | {
+            type: "ALTER_RENAME_COLUMN";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            from: string;
+            to: string;
+        } | {
+            type: "ALTER_ADD";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            column: {
+                name: string;
+                type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                primary: boolean;
+                auto_increment: boolean;
+                not_null: boolean;
+                unique: boolean;
+                default: string | number | null;
+                references: {
+                    table: {
+                        scheme_parts: string[];
+                        name: string;
+                    };
+                    columns: string[];
+                    constraints: string | null;
+                } | null;
+            };
+        } | {
+            type: "ALTER_DROP";
+            table: {
+                scheme_parts: string[];
+                name: string;
+            };
+            column_name: string;
+        };
+        linked: Map<"SAVE/RELEASE" | "LINK_TABLE", Set<{
+            type: "LINK";
+            sub_type: "SAVE/RELEASE" | "LINK_TABLE";
+            index: number | {
+                from: number;
+                to: number;
+            };
+            child: (/*elided*/ any | /*elided*/ any)[];
+        } | /*elided*/ any>>;
+    }) => boolean): {
+        type: "LINK";
+        sub_type: "SAVE/RELEASE" | "LINK_TABLE";
+        index: number | {
+            from: number;
+            to: number;
+        };
+        child: (/*elided*/ any | {
+            type: "LINK_SQLITE";
+            index: number;
+            link: {
+                type: "PRAGMA";
+                name: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                value: string | number | null;
+            } | {
+                type: "SAVEPOINT";
+                savepoint_name: string | null;
+            } | {
+                type: "RELEASE";
+                savepoint_name: string | null;
+            } | {
+                type: "SELECT";
+                distinct: boolean;
+                columns: Exclude<{
+                    name: string;
+                    as: string | null;
+                    sort: "ASC" | "DESC" | null;
+                }, "sort">[];
+                from: {
+                    scheme_parts: string[];
+                    name: string;
+                }[];
+                where: string | null;
+                group_by: string | null;
+                order_by: string | null;
+                limit: number | null;
+                offset: number | null;
+            } | {
+                type: "CREATE_TABLE";
+                table: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                if_not_exists: boolean;
+                columns: {
+                    name: string;
+                    type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                    primary: boolean;
+                    auto_increment: boolean;
+                    not_null: boolean;
+                    unique: boolean;
+                    default: string | number | null;
+                    references: {
+                        table: {
+                            scheme_parts: string[];
+                            name: string;
+                        };
+                        columns: string[];
+                        constraints: string | null;
+                    } | null;
+                }[];
+            } | {
+                type: "CREATE_INDEX";
+                name: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                table_name: string;
+                if_not_exists: boolean;
+                unique: boolean;
+                columns: Omit<{
+                    name: string;
+                    as: string | null;
+                    sort: "ASC" | "DESC" | null;
+                }, "as">[];
+            } | {
+                type: "VALUES";
+                values: (number | string)[];
+            } | {
+                type: "INSERT";
+                table: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                columns: Omit<Omit<{
+                    name: string;
+                    as: string | null;
+                    sort: "ASC" | "DESC" | null;
+                }, "as">, "sort">[];
+                expr: {
+                    type: "VALUES";
+                    values: (number | string)[];
+                } | {
+                    type: "SELECT";
+                    distinct: boolean;
+                    columns: Exclude<{
+                        name: string;
+                        as: string | null;
+                        sort: "ASC" | "DESC" | null;
+                    }, "sort">[];
+                    from: {
+                        scheme_parts: string[];
+                        name: string;
+                    }[];
+                    where: string | null;
+                    group_by: string | null;
+                    order_by: string | null;
+                    limit: number | null;
+                    offset: number | null;
+                };
+            } | {
+                type: "DROP_TABLE";
+                table: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                if_not_exists: boolean;
+            } | {
+                type: "DROP_INDEX";
+                name: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                if_not_exists: boolean;
+            } | {
+                type: "ALTER_RENAME_TO";
+                table: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                to: string;
+            } | {
+                type: "ALTER_RENAME_COLUMN";
+                table: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                from: string;
+                to: string;
+            } | {
+                type: "ALTER_ADD";
+                table: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                column: {
+                    name: string;
+                    type: "TEXT" | "INTEGER" | "REAL" | "BLOB" | "DATETIME";
+                    primary: boolean;
+                    auto_increment: boolean;
+                    not_null: boolean;
+                    unique: boolean;
+                    default: string | number | null;
+                    references: {
+                        table: {
+                            scheme_parts: string[];
+                            name: string;
+                        };
+                        columns: string[];
+                        constraints: string | null;
+                    } | null;
+                };
+            } | {
+                type: "ALTER_DROP";
+                table: {
+                    scheme_parts: string[];
+                    name: string;
+                };
+                column_name: string;
+            };
+            linked: Map<"SAVE/RELEASE" | "LINK_TABLE", Set</*elided*/ any | /*elided*/ any>>;
+        })[];
+    }[];
+    /** @param {string} sql */
+    Heuristics_DBBrowserForSQLite(sql: string): void;
+    /** @param {string | TemplateStringsArray} sql */
+    execFrom_DBBrowser(sql: string | TemplateStringsArray): void;
+}
+//# sourceMappingURL=SQLParser.d.ts.map