@pleaseai/agent 0.1.16 → 0.1.18

package/.output/server/node_modules/kysely/dist/esm/dialect/mysql/mysql-driver.js

@@ -0,0 +1,177 @@
+/// <reference types="./mysql-driver.d.ts" />
+import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { isFunction, isObject, freeze } from '../../util/object-utils.js';
+import { createQueryId } from '../../util/query-id.js';
+import { extendStackTrace } from '../../util/stack-trace-utils.js';
+const PRIVATE_RELEASE_METHOD = Symbol();
+export class MysqlDriver {
+    #config;
+    #connections = new WeakMap();
+    #pool;
+    constructor(configOrPool) {
+        this.#config = freeze({ ...configOrPool });
+    }
+    async init() {
+        this.#pool = isFunction(this.#config.pool)
+            ? await this.#config.pool()
+            : this.#config.pool;
+    }
+    async acquireConnection() {
+        const rawConnection = await this.#acquireConnection();
+        let connection = this.#connections.get(rawConnection);
+        if (!connection) {
+            connection = new MysqlConnection(rawConnection);
+            this.#connections.set(rawConnection, connection);
+            // The driver must take care of calling `onCreateConnection` when a new
+            // connection is created. The `mysql2` module doesn't provide an async hook
+            // for the connection creation. We need to call the method explicitly.
+            if (this.#config?.onCreateConnection) {
+                await this.#config.onCreateConnection(connection);
+            }
+        }
+        if (this.#config?.onReserveConnection) {
+            await this.#config.onReserveConnection(connection);
+        }
+        return connection;
+    }
+    async #acquireConnection() {
+        return new Promise((resolve, reject) => {
+            this.#pool.getConnection(async (err, rawConnection) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(rawConnection);
+                }
+            });
+        });
+    }
+    async beginTransaction(connection, settings) {
+        if (settings.isolationLevel || settings.accessMode) {
+            const parts = [];
+            if (settings.isolationLevel) {
+                parts.push(`isolation level ${settings.isolationLevel}`);
+            }
+            if (settings.accessMode) {
+                parts.push(settings.accessMode);
+            }
+            const sql = `set transaction ${parts.join(', ')}`;
+            // On MySQL this sets the isolation level of the next transaction.
+            await connection.executeQuery(CompiledQuery.raw(sql));
+        }
+        await connection.executeQuery(CompiledQuery.raw('begin'));
+    }
+    async commitTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('commit'));
+    }
+    async rollbackTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('rollback'));
+    }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to', savepointName), createQueryId()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('release savepoint', savepointName), createQueryId()));
+    }
+    async releaseConnection(connection) {
+        connection[PRIVATE_RELEASE_METHOD]();
+    }
+    async destroy() {
+        return new Promise((resolve, reject) => {
+            this.#pool.end((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+}
+function isOkPacket(obj) {
+    return isObject(obj) && 'insertId' in obj && 'affectedRows' in obj;
+}
+class MysqlConnection {
+    #rawConnection;
+    constructor(rawConnection) {
+        this.#rawConnection = rawConnection;
+    }
+    async executeQuery(compiledQuery) {
+        try {
+            const result = await this.#executeQuery(compiledQuery);
+            if (isOkPacket(result)) {
+                const { insertId, affectedRows, changedRows } = result;
+                return {
+                    insertId: insertId !== undefined &&
+                        insertId !== null &&
+                        insertId.toString() !== '0'
+                        ? BigInt(insertId)
+                        : undefined,
+                    numAffectedRows: affectedRows !== undefined && affectedRows !== null
+                        ? BigInt(affectedRows)
+                        : undefined,
+                    numChangedRows: changedRows !== undefined && changedRows !== null
+                        ? BigInt(changedRows)
+                        : undefined,
+                    rows: [],
+                };
+            }
+            else if (Array.isArray(result)) {
+                return {
+                    rows: result,
+                };
+            }
+            return {
+                rows: [],
+            };
+        }
+        catch (err) {
+            throw extendStackTrace(err, new Error());
+        }
+    }
+    #executeQuery(compiledQuery) {
+        return new Promise((resolve, reject) => {
+            this.#rawConnection.query(compiledQuery.sql, compiledQuery.parameters, (err, result) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(result);
+                }
+            });
+        });
+    }
+    async *streamQuery(compiledQuery, _chunkSize) {
+        const stream = this.#rawConnection
+            .query(compiledQuery.sql, compiledQuery.parameters)
+            .stream({
+            objectMode: true,
+        });
+        try {
+            for await (const row of stream) {
+                yield {
+                    rows: [row],
+                };
+            }
+        }
+        catch (ex) {
+            if (ex &&
+                typeof ex === 'object' &&
+                'code' in ex &&
+                // @ts-ignore
+                ex.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+                // Most likely because of https://github.com/mysqljs/mysql/blob/master/lib/protocol/sequences/Query.js#L220
+                return;
+            }
+            throw ex;
+        }
+    }
+    [PRIVATE_RELEASE_METHOD]() {
+        this.#rawConnection.release();
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/dialect/mysql/mysql-introspector.js

@@ -0,0 +1,76 @@
+/// <reference types="./mysql-introspector.d.ts" />
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
+import { freeze } from '../../util/object-utils.js';
+import { sql } from '../../raw-builder/sql.js';
+export class MysqlIntrospector {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    async getSchemas() {
+        let rawSchemas = await this.#db
+            .selectFrom('information_schema.schemata')
+            .select('schema_name')
+            .$castTo()
+            .execute();
+        return rawSchemas.map((it) => ({ name: it.SCHEMA_NAME }));
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
+        let query = this.#db
+            .selectFrom('information_schema.columns as columns')
+            .innerJoin('information_schema.tables as tables', (b) => b
+            .onRef('columns.TABLE_CATALOG', '=', 'tables.TABLE_CATALOG')
+            .onRef('columns.TABLE_SCHEMA', '=', 'tables.TABLE_SCHEMA')
+            .onRef('columns.TABLE_NAME', '=', 'tables.TABLE_NAME'))
+            .select([
+            'columns.COLUMN_NAME',
+            'columns.COLUMN_DEFAULT',
+            'columns.TABLE_NAME',
+            'columns.TABLE_SCHEMA',
+            'tables.TABLE_TYPE',
+            'columns.IS_NULLABLE',
+            'columns.DATA_TYPE',
+            'columns.EXTRA',
+            'columns.COLUMN_COMMENT',
+        ])
+            .where('columns.TABLE_SCHEMA', '=', sql `database()`)
+            .orderBy('columns.TABLE_NAME')
+            .orderBy('columns.ORDINAL_POSITION')
+            .$castTo();
+        if (!options.withInternalKyselyTables) {
+            query = query
+                .where('columns.TABLE_NAME', '!=', DEFAULT_MIGRATION_TABLE)
+                .where('columns.TABLE_NAME', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
+        }
+        const rawColumns = await query.execute();
+        return this.#parseTableMetadata(rawColumns);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+    #parseTableMetadata(columns) {
+        return columns.reduce((tables, it) => {
+            let table = tables.find((tbl) => tbl.name === it.TABLE_NAME);
+            if (!table) {
+                table = freeze({
+                    name: it.TABLE_NAME,
+                    isView: it.TABLE_TYPE === 'VIEW',
+                    schema: it.TABLE_SCHEMA,
+                    columns: [],
+                });
+                tables.push(table);
+            }
+            table.columns.push(freeze({
+                name: it.COLUMN_NAME,
+                dataType: it.DATA_TYPE,
+                isNullable: it.IS_NULLABLE === 'YES',
+                isAutoIncrementing: it.EXTRA.toLowerCase().includes('auto_increment'),
+                hasDefaultValue: it.COLUMN_DEFAULT !== null,
+                comment: it.COLUMN_COMMENT === '' ? undefined : it.COLUMN_COMMENT,
+            }));
+            return tables;
+        }, []);
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/dialect/mysql/mysql-query-compiler.js

@@ -0,0 +1,68 @@
+/// <reference types="./mysql-query-compiler.d.ts" />
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+const LITERAL_ESCAPE_REGEX = /\\|'/g;
+const ID_WRAP_REGEX = /`/g;
+export class MysqlQueryCompiler extends DefaultQueryCompiler {
+    getCurrentParameterPlaceholder() {
+        return '?';
+    }
+    getLeftExplainOptionsWrapper() {
+        return '';
+    }
+    getExplainOptionAssignment() {
+        return '=';
+    }
+    getExplainOptionsDelimiter() {
+        return ' ';
+    }
+    getRightExplainOptionsWrapper() {
+        return '';
+    }
+    getLeftIdentifierWrapper() {
+        return ID_WRAP_REGEX.source;
+    }
+    getRightIdentifierWrapper() {
+        return ID_WRAP_REGEX.source;
+    }
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '``');
+    }
+    /**
+     * MySQL requires escaping backslashes in string literals when using the
+     * default NO_BACKSLASH_ESCAPES=OFF mode. Without this, a backslash
+     * followed by a quote (\') can break out of the string literal.
+     *
+     * @see https://dev.mysql.com/doc/refman/9.6/en/string-literals.html
+     */
+    sanitizeStringLiteral(value) {
+        return value.replace(LITERAL_ESCAPE_REGEX, (char) => char === '\\' ? '\\\\' : "''");
+    }
+    visitCreateIndex(node) {
+        this.append('create ');
+        if (node.unique) {
+            this.append('unique ');
+        }
+        this.append('index ');
+        if (node.ifNotExists) {
+            this.append('if not exists ');
+        }
+        this.visitNode(node.name);
+        if (node.using) {
+            this.append(' using ');
+            this.visitNode(node.using);
+        }
+        if (node.table) {
+            this.append(' on ');
+            this.visitNode(node.table);
+        }
+        if (node.columns) {
+            this.append(' (');
+            this.compileList(node.columns);
+            this.append(')');
+        }
+        if (node.where) {
+            this.append(' ');
+            this.visitNode(node.where);
+        }
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/dialect/postgres/postgres-adapter.js

@@ -0,0 +1,22 @@
+/// <reference types="./postgres-adapter.d.ts" />
+import { sql } from '../../raw-builder/sql.js';
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+// Random id for our transaction lock.
+const LOCK_ID = BigInt('3853314791062309107');
+export class PostgresAdapter extends DialectAdapterBase {
+    get supportsTransactionalDdl() {
+        return true;
+    }
+    get supportsReturning() {
+        return true;
+    }
+    async acquireMigrationLock(db, _opt) {
+        // Acquire a transaction level advisory lock.
+        await sql `select pg_advisory_xact_lock(${sql.lit(LOCK_ID)})`.execute(db);
+    }
+    async releaseMigrationLock(_db, _opt) {
+        // Nothing to do here. `pg_advisory_xact_lock` is automatically released at the
+        // end of the transaction and since `supportsTransactionalDdl` true, we know
+        // the `db` instance passed to acquireMigrationLock is actually a transaction.
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/dialect/postgres/postgres-dialect-config.js

@@ -0,0 +1,2 @@
+/// <reference types="./postgres-dialect-config.d.ts" />
+export {};

package/.output/server/node_modules/kysely/dist/esm/dialect/postgres/postgres-dialect.js

@@ -0,0 +1,53 @@
+/// <reference types="./postgres-dialect.d.ts" />
+import { PostgresDriver } from './postgres-driver.js';
+import { PostgresIntrospector } from './postgres-introspector.js';
+import { PostgresQueryCompiler } from './postgres-query-compiler.js';
+import { PostgresAdapter } from './postgres-adapter.js';
+/**
+ * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
+ *
+ * The constructor takes an instance of {@link PostgresDialectConfig}.
+ *
+ * ```ts
+ * import { Pool } from 'pg'
+ *
+ * new PostgresDialect({
+ *   pool: new Pool({
+ *     database: 'some_db',
+ *     host: 'localhost',
+ *   })
+ * })
+ * ```
+ *
+ * If you want the pool to only be created once it's first used, `pool`
+ * can be a function:
+ *
+ * ```ts
+ * import { Pool } from 'pg'
+ *
+ * new PostgresDialect({
+ *   pool: async () => new Pool({
+ *     database: 'some_db',
+ *     host: 'localhost',
+ *   })
+ * })
+ * ```
+ */
+export class PostgresDialect {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    createDriver() {
+        return new PostgresDriver(this.#config);
+    }
+    createQueryCompiler() {
+        return new PostgresQueryCompiler();
+    }
+    createAdapter() {
+        return new PostgresAdapter();
+    }
+    createIntrospector(db) {
+        return new PostgresIntrospector(db);
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/dialect/postgres/postgres-driver.js

@@ -0,0 +1,131 @@
+/// <reference types="./postgres-driver.d.ts" />
+import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { isFunction, freeze } from '../../util/object-utils.js';
+import { createQueryId } from '../../util/query-id.js';
+import { extendStackTrace } from '../../util/stack-trace-utils.js';
+const PRIVATE_RELEASE_METHOD = Symbol();
+export class PostgresDriver {
+    #config;
+    #connections = new WeakMap();
+    #pool;
+    constructor(config) {
+        this.#config = freeze({ ...config });
+    }
+    async init() {
+        this.#pool = isFunction(this.#config.pool)
+            ? await this.#config.pool()
+            : this.#config.pool;
+    }
+    async acquireConnection() {
+        const client = await this.#pool.connect();
+        let connection = this.#connections.get(client);
+        if (!connection) {
+            connection = new PostgresConnection(client, {
+                cursor: this.#config.cursor ?? null,
+            });
+            this.#connections.set(client, connection);
+            // The driver must take care of calling `onCreateConnection` when a new
+            // connection is created. The `pg` module doesn't provide an async hook
+            // for the connection creation. We need to call the method explicitly.
+            if (this.#config.onCreateConnection) {
+                await this.#config.onCreateConnection(connection);
+            }
+        }
+        if (this.#config.onReserveConnection) {
+            await this.#config.onReserveConnection(connection);
+        }
+        return connection;
+    }
+    async beginTransaction(connection, settings) {
+        if (settings.isolationLevel || settings.accessMode) {
+            let sql = 'start transaction';
+            if (settings.isolationLevel) {
+                sql += ` isolation level ${settings.isolationLevel}`;
+            }
+            if (settings.accessMode) {
+                sql += ` ${settings.accessMode}`;
+            }
+            await connection.executeQuery(CompiledQuery.raw(sql));
+        }
+        else {
+            await connection.executeQuery(CompiledQuery.raw('begin'));
+        }
+    }
+    async commitTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('commit'));
+    }
+    async rollbackTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('rollback'));
+    }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to', savepointName), createQueryId()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('release', savepointName), createQueryId()));
+    }
+    async releaseConnection(connection) {
+        connection[PRIVATE_RELEASE_METHOD]();
+    }
+    async destroy() {
+        if (this.#pool) {
+            const pool = this.#pool;
+            this.#pool = undefined;
+            await pool.end();
+        }
+    }
+}
+class PostgresConnection {
+    #client;
+    #options;
+    constructor(client, options) {
+        this.#client = client;
+        this.#options = options;
+    }
+    async executeQuery(compiledQuery) {
+        try {
+            const { command, rowCount, rows } = await this.#client.query(compiledQuery.sql, [...compiledQuery.parameters]);
+            return {
+                numAffectedRows: command === 'INSERT' ||
+                    command === 'UPDATE' ||
+                    command === 'DELETE' ||
+                    command === 'MERGE'
+                    ? BigInt(rowCount)
+                    : undefined,
+                rows: rows ?? [],
+            };
+        }
+        catch (err) {
+            throw extendStackTrace(err, new Error());
+        }
+    }
+    async *streamQuery(compiledQuery, chunkSize) {
+        if (!this.#options.cursor) {
+            throw new Error("'cursor' is not present in your postgres dialect config. It's required to make streaming work in postgres.");
+        }
+        if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+            throw new Error('chunkSize must be a positive integer');
+        }
+        const cursor = this.#client.query(new this.#options.cursor(compiledQuery.sql, compiledQuery.parameters.slice()));
+        try {
+            while (true) {
+                const rows = await cursor.read(chunkSize);
+                if (rows.length === 0) {
+                    break;
+                }
+                yield {
+                    rows,
+                };
+            }
+        }
+        finally {
+            await cursor.close();
+        }
+    }
+    [PRIVATE_RELEASE_METHOD]() {
+        this.#client.release();
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/dialect/postgres/postgres-introspector.js

@@ -0,0 +1,97 @@
+/// <reference types="./postgres-introspector.d.ts" />
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
+import { freeze } from '../../util/object-utils.js';
+import { sql } from '../../raw-builder/sql.js';
+export class PostgresIntrospector {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    async getSchemas() {
+        let rawSchemas = await this.#db
+            .selectFrom('pg_catalog.pg_namespace')
+            .select('nspname')
+            .$castTo()
+            .execute();
+        return rawSchemas.map((it) => ({ name: it.nspname }));
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
+        let query = this.#db
+            // column
+            .selectFrom('pg_catalog.pg_attribute as a')
+            // table
+            .innerJoin('pg_catalog.pg_class as c', 'a.attrelid', 'c.oid')
+            // table schema
+            .innerJoin('pg_catalog.pg_namespace as ns', 'c.relnamespace', 'ns.oid')
+            // column data type
+            .innerJoin('pg_catalog.pg_type as typ', 'a.atttypid', 'typ.oid')
+            // column data type schema
+            .innerJoin('pg_catalog.pg_namespace as dtns', 'typ.typnamespace', 'dtns.oid')
+            .select([
+            'a.attname as column',
+            'a.attnotnull as not_null',
+            'a.atthasdef as has_default',
+            'c.relname as table',
+            'c.relkind as table_type',
+            'ns.nspname as schema',
+            'typ.typname as type',
+            'dtns.nspname as type_schema',
+            sql `col_description(a.attrelid, a.attnum)`.as('column_description'),
+            sql `pg_get_serial_sequence(quote_ident(ns.nspname) || '.' || quote_ident(c.relname), a.attname)`.as('auto_incrementing'),
+        ])
+            .where('c.relkind', 'in', [
+            'r' /*regular table*/,
+            'v' /*view*/,
+            'p' /*partitioned table*/,
+        ])
+            .where('ns.nspname', '!~', '^pg_')
+            .where('ns.nspname', '!=', 'information_schema')
+            // Filter out internal cockroachdb schema
+            .where('ns.nspname', '!=', 'crdb_internal')
+            // Only schemas where we are allowed access
+            .where(sql `has_schema_privilege(ns.nspname, 'USAGE')`)
+            // No system columns
+            .where('a.attnum', '>=', 0)
+            .where('a.attisdropped', '!=', true)
+            .orderBy('ns.nspname')
+            .orderBy('c.relname')
+            .orderBy('a.attnum')
+            .$castTo();
+        if (!options.withInternalKyselyTables) {
+            query = query
+                .where('c.relname', '!=', DEFAULT_MIGRATION_TABLE)
+                .where('c.relname', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
+        }
+        const rawColumns = await query.execute();
+        return this.#parseTableMetadata(rawColumns);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+    #parseTableMetadata(columns) {
+        return columns.reduce((tables, it) => {
+            let table = tables.find((tbl) => tbl.name === it.table && tbl.schema === it.schema);
+            if (!table) {
+                table = freeze({
+                    name: it.table,
+                    isView: it.table_type === 'v',
+                    schema: it.schema,
+                    columns: [],
+                });
+                tables.push(table);
+            }
+            table.columns.push(freeze({
+                name: it.column,
+                dataType: it.type,
+                dataTypeSchema: it.type_schema,
+                isNullable: !it.not_null,
+                isAutoIncrementing: it.auto_incrementing !== null,
+                hasDefaultValue: it.has_default,
+                comment: it.column_description ?? undefined,
+            }));
+            return tables;
+        }, []);
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/dialect/postgres/postgres-query-compiler.js

@@ -0,0 +1,8 @@
+/// <reference types="./postgres-query-compiler.d.ts" />
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+const ID_WRAP_REGEX = /"/g;
+export class PostgresQueryCompiler extends DefaultQueryCompiler {
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '""');
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-adapter.js

@@ -0,0 +1,20 @@
+/// <reference types="./sqlite-adapter.d.ts" />
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export class SqliteAdapter extends DialectAdapterBase {
+    get supportsTransactionalDdl() {
+        return false;
+    }
+    get supportsReturning() {
+        return true;
+    }
+    async acquireMigrationLock(_db, _opt) {
+        // SQLite only has one connection that's reserved by the migration system
+        // for the whole time between acquireMigrationLock and releaseMigrationLock.
+        // We don't need to do anything here.
+    }
+    async releaseMigrationLock(_db, _opt) {
+        // SQLite only has one connection that's reserved by the migration system
+        // for the whole time between acquireMigrationLock and releaseMigrationLock.
+        // We don't need to do anything here.
+    }
+}

package/.output/server/node_modules/kysely/dist/esm/dialect/sqlite/sqlite-dialect-config.js

@@ -0,0 +1,2 @@
+/// <reference types="./sqlite-dialect-config.d.ts" />
+export {};