kysely 0.28.17 → 0.29.0

package/dist/dialect/mysql/mysql-dialect-config.d.ts

@@ -0,0 +1,69 @@
+import type { DatabaseConnection } from '../../driver/database-connection.js';
+import type { AbortableOperationOptions } from '../../util/abort.js';
+/**
+ * Config for the MySQL dialect.
+ */
+export interface MysqlDialectConfig {
+    /**
+     * A `mysql2` `Client` constructor, to be used for connecting to the database
+     * outside of the `pool` to avoid waiting for an idle connection.
+     *
+     * This is useful for cancelling queries on the database side.
+     */
+    controlConnection?: (config: object) => MysqlConnection;
+    /**
+     * A mysql2 Pool instance or a function that returns one.
+     *
+     * If a function is provided, it's called once when the first query is executed.
+     *
+     * https://github.com/sidorares/node-mysql2#using-connection-pools
+     */
+    pool: MysqlPool | ((options?: AbortableOperationOptions) => Promise<MysqlPool>);
+    /**
+     * Called once for each created connection.
+     */
+    onCreateConnection?: (connection: DatabaseConnection, options?: AbortableOperationOptions) => Promise<void>;
+    /**
+     * Called every time a connection is acquired from the pool.
+     */
+    onReserveConnection?: (connection: DatabaseConnection, options?: AbortableOperationOptions) => Promise<void>;
+}
+/**
+ * This interface is the subset of mysql2 driver's `Pool` class that
+ * kysely needs.
+ *
+ * We don't use the type from `mysql2` here to not have a dependency to it.
+ *
+ * https://github.com/sidorares/node-mysql2#using-connection-pools
+ */
+export interface MysqlPool {
+    getConnection(callback: (error: unknown, connection: MysqlPoolConnection) => void): void;
+    end(callback: (error: unknown) => void): void;
+}
+export interface MysqlConnection {
+    config: object;
+    connect(callback?: (error: unknown) => void): void;
+    destroy(): void;
+    query(sql: string, parameters: Array<unknown>): {
+        stream: <T>(options: MysqlStreamOptions) => MysqlStream<T>;
+    };
+    query(sql: string, parameters: Array<unknown>, callback: (error: unknown, result: MysqlQueryResult) => void): void;
+    threadId: number;
+}
+export type MysqlConectionConstructor = new (opts?: object) => MysqlConnection;
+export interface MysqlPoolConnection extends MysqlConnection {
+    release(): void;
+}
+export interface MysqlStreamOptions {
+    highWaterMark?: number;
+    objectMode?: true;
+}
+export interface MysqlStream<T> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+export interface MysqlOkPacket {
+    affectedRows: number;
+    changedRows: number;
+    insertId: number;
+}
+export type MysqlQueryResult = MysqlOkPacket | Record<string, unknown>[];

package/dist/dialect/mysql/mysql-driver.d.ts

@@ -0,0 +1,56 @@
+import type { ControlConnectionProvider, DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
+import type { Driver, TransactionSettings } from '../../driver/driver.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import type { QueryCompiler } from '../../query-compiler/query-compiler.js';
+import type { AbortableOperationOptions } from '../../util/abort.js';
+import type { MysqlDialectConfig, MysqlPoolConnection } from './mysql-dialect-config.js';
+declare const PRIVATE_RELEASE_METHOD: unique symbol;
+export declare class MysqlDriver implements Driver {
+    #private;
+    constructor(config: MysqlDialectConfig);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     */
+    init(options?: AbortableOperationOptions): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(options?: AbortableOperationOptions): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(connection: MysqlConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+}
+declare class MysqlConnection implements DatabaseConnection {
+    #private;
+    constructor(connection: MysqlPoolConnection, controlConnection: MysqlDialectConfig['controlConnection']);
+    cancelQuery(controlConnectionProvider: ControlConnectionProvider): Promise<void>;
+    collectSessionInfo(): Promise<void>;
+    executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    killSession(controlConnectionProvider: ControlConnectionProvider): Promise<void>;
+    streamQuery<O>(compiledQuery: CompiledQuery, _chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
+    [PRIVATE_RELEASE_METHOD](): void;
+}
+export {};

package/dist/dialect/mysql/mysql-driver.js

@@ -0,0 +1,252 @@
+/// <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(config) {
+        this.#config = freeze({ ...config });
+    }
+    async init(options) {
+        this.#pool = isFunction(this.#config.pool)
+            ? await this.#config.pool(options)
+            : this.#config.pool;
+    }
+    async acquireConnection(options) {
+        const rawConnection = await this.#acquireConnection();
+        let connection = this.#connections.get(rawConnection);
+        if (!connection) {
+            connection = new MysqlConnection(rawConnection, this.#config.controlConnection);
+            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, options);
+            }
+        }
+        if (this.#config?.onReserveConnection) {
+            await this.#config.onReserveConnection(connection, options);
+        }
+        return connection;
+    }
+    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();
+                }
+            });
+        });
+    }
+    async #acquireConnection() {
+        return new Promise((resolve, reject) => {
+            this.#pool.getConnection(async (err, rawConnection) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(rawConnection);
+                }
+            });
+        });
+    }
+}
+function isOkPacket(obj) {
+    return isObject(obj) && 'insertId' in obj && 'affectedRows' in obj;
+}
+class MysqlConnection {
+    #connection;
+    #controlConnection;
+    #cid;
+    #queryId;
+    constructor(connection, controlConnection) {
+        this.#connection = connection;
+        this.#controlConnection = controlConnection;
+    }
+    async cancelQuery(controlConnectionProvider) {
+        await this.#executeControlQuery(`kill query ${this.#cid}`, controlConnectionProvider);
+    }
+    async collectSessionInfo() {
+        if (this.#cid) {
+            return;
+        }
+        const { threadId } = this.#connection;
+        if (threadId != null) {
+            this.#cid = threadId;
+        }
+        else {
+            const [{ cid }] = (await this.#executeQuery(CompiledQuery.raw(`select connection_id() as cid`)));
+            this.#cid = Number(cid);
+        }
+    }
+    async executeQuery(compiledQuery) {
+        try {
+            // this helps ensure we don't cancel the wrong query when aborted.
+            this.#queryId = compiledQuery.queryId;
+            const result = await this.#executeQuery(compiledQuery);
+            if (!isOkPacket(result)) {
+                return {
+                    rows: (Array.isArray(result) ? result : []),
+                };
+            }
+            const { insertId, affectedRows, changedRows } = result;
+            return {
+                insertId: insertId != null && insertId.toString() !== '0'
+                    ? BigInt(insertId)
+                    : undefined,
+                numAffectedRows: affectedRows != null ? BigInt(affectedRows) : undefined,
+                numChangedRows: changedRows != null ? BigInt(changedRows) : undefined,
+                rows: [],
+            };
+        }
+        catch (err) {
+            throw extendStackTrace(err, new Error());
+        }
+        finally {
+            // this tells cancellation the query is no longer relevant.
+            this.#queryId = undefined;
+        }
+    }
+    async killSession(controlConnectionProvider) {
+        try {
+            // this removes the connection from the pool.
+            // this is done to avoid picking it up after the `kill` command next, which
+            // would cause an error when attempting to query.
+            this.#connection.destroy();
+        }
+        catch {
+            // noop
+        }
+        await this.#executeControlQuery(`kill connection ${this.#cid}`, controlConnectionProvider);
+    }
+    async *streamQuery(compiledQuery, _chunkSize) {
+        // this helps ensure we don't cancel the wrong query when aborted.
+        this.#queryId = compiledQuery.queryId;
+        const stream = this.#connection
+            .query(compiledQuery.sql, compiledQuery.parameters)
+            .stream({ objectMode: true });
+        try {
+            for await (const row of stream) {
+                yield {
+                    rows: [row],
+                };
+            }
+        }
+        catch (error) {
+            if (isObject(error) &&
+                'code' in error &&
+                // @ts-ignore
+                error.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+                // Most likely because of https://github.com/mysqljs/mysql/blob/master/lib/protocol/sequences/Query.js#L220
+                return;
+            }
+            throw error;
+        }
+        finally {
+            // this tells cancellation the query is no longer relevant.
+            this.#queryId = undefined;
+        }
+    }
+    [PRIVATE_RELEASE_METHOD]() {
+        this.#connection.release();
+    }
+    #executeQuery(compiledQuery) {
+        return new Promise((resolve, reject) => {
+            this.#connection.query(compiledQuery.sql, compiledQuery.parameters, (err, result) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(result);
+                }
+            });
+        });
+    }
+    async #executeControlQuery(query, controlConnectionProvider) {
+        if (!this.#queryId) {
+            return;
+        }
+        const { config } = this.#connection;
+        const queryIdToCancel = this.#queryId;
+        // we fallback to a pool connection, and execute a SQL query to cancel the
+        // query. this is not ideal, as we might have to wait for an idle connection.
+        if (!this.#controlConnection || !config) {
+            return await controlConnectionProvider(async (controlConnection) => {
+                // by the time we get the connection, another query might have been executed.
+                // we need to ensure we're not canceling the wrong query.
+                if (queryIdToCancel.queryId === this.#queryId?.queryId) {
+                    await controlConnection.executeQuery(CompiledQuery.raw(query, []));
+                }
+            });
+        }
+        const { 
+        // omitting these as they cause a warning and perhaps a future error when passed.
+        clientFlags: _, maxPacketSize: __, ...cfg } = config;
+        const controlConnection = this.#controlConnection(cfg);
+        try {
+            await new Promise((resolve, reject) => {
+                controlConnection.connect((connectError) => {
+                    if (connectError) {
+                        return reject(connectError);
+                    }
+                    // by the time we get the connection, another query might have been executed.
+                    // we need to ensure we're not canceling the wrong query.
+                    if (queryIdToCancel.queryId !== this.#queryId?.queryId) {
+                        return resolve();
+                    }
+                    controlConnection.query(query, [], (queryError) => {
+                        if (queryError) {
+                            return reject(queryError);
+                        }
+                        resolve();
+                    });
+                });
+            });
+        }
+        finally {
+            controlConnection.destroy();
+        }
+    }
+}

package/dist/dialect/mysql/mysql-introspector.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { Kysely } from '../../kysely.js';
+export declare class MysqlIntrospector implements DatabaseIntrospector {
+    #private;
+    constructor(db: Kysely<any>);
+    /**
+     * Get schema metadata.
+     */
+    getSchemas(): Promise<SchemaMetadata[]>;
+    /**
+     * Get tables and views metadata.
+     */
+    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
+}

package/dist/dialect/mysql/mysql-introspector.js

@@ -0,0 +1,73 @@
+/// <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',
+            'tables.ENGINE',
+            '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);
+    }
+    #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',
+                    isForeign: it.ENGINE === 'FEDERATED',
+                    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/dist/dialect/pglite/pglite-adapter.d.ts

@@ -0,0 +1,68 @@
+import { PostgresAdapter } from '../postgres/postgres-adapter.js';
+export declare class PGliteAdapter extends PostgresAdapter {
+    get supportsMultipleConnections(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration operations to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * import { DialectAdapterBase, type MigrationLockOptions, Kysely } from 'kysely'
+     *
+     * export class MyAdapter extends DialectAdapterBase {
+     *   override async acquireMigrationLock(
+     *     db: Kysely<any>,
+     *     options: MigrationLockOptions
+     *   ): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
+     * }
+     * ```
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
+    acquireMigrationLock(): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
+    releaseMigrationLock(): Promise<void>;
+}

package/dist/dialect/pglite/pglite-adapter.js

@@ -0,0 +1,17 @@
+/// <reference types="./pglite-adapter.d.ts" />
+import { PostgresAdapter } from '../postgres/postgres-adapter.js';
+export class PGliteAdapter extends PostgresAdapter {
+    get supportsMultipleConnections() {
+        return false;
+    }
+    async acquireMigrationLock() {
+        // PGlite 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() {
+        // PGlite 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/dist/dialect/pglite/pglite-dialect-config.d.ts

@@ -0,0 +1,58 @@
+import type { DatabaseConnection } from '../../driver/database-connection.js';
+import type { AbortableOperationOptions } from '../../util/abort.js';
+/**
+ * Config for the PGlite dialect.
+ */
+export interface PGliteDialectConfig {
+    /**
+     * Called once when the first query is executed.
+     *
+     * This is a Kysely specific feature and does not come from the `@electric-sql/pglite`
+     * module.
+     */
+    onCreateConnection?: (connection: DatabaseConnection, options?: AbortableOperationOptions) => Promise<void>;
+    /**
+     * A PGlite instance or a function that returns one.
+     *
+     * If a function is provided, it's called once when the first query is executed.
+     *
+     * https://pglite.dev/docs/api#main-constructor
+     */
+    pglite: PGlite | ((options?: AbortableOperationOptions) => PGlite | Promise<PGlite>);
+}
+/**
+ * This interface is the subset of the PGlite instance that kysely needs.
+ *
+ * We don't use the type from `@electric-sql/pglite` here to not have a dependency
+ * to it.
+ *
+ * https://pglite.dev/docs/api
+ */
+export interface PGlite {
+    close(): Promise<void>;
+    closed: boolean;
+    query<T>(query: string, params?: any[], options?: PGliteQueryOptions): Promise<PGliteQueryResults<T>>;
+    ready: boolean;
+    transaction<T>(callback: (tx: PGliteTransaction) => Promise<T>): Promise<T>;
+    waitReady: Promise<void>;
+}
+export interface PGliteQueryOptions {
+    blob?: Blob | File;
+    onNotice?: (notice: any) => void;
+    paramTypes?: number[];
+    parsers?: Record<number, (value: string) => any>;
+    rowMode?: 'array' | 'object';
+    serializers?: Record<number, (value: any) => string>;
+}
+export interface PGliteQueryResults<T> {
+    affectedRows?: number;
+    blob?: Blob;
+    fields: {
+        dataTypeID: number;
+        name: string;
+    }[];
+    rows: T[];
+}
+export interface PGliteTransaction extends Pick<PGlite, 'query'> {
+    rollback(): Promise<void>;
+}

package/dist/dialect/pglite/pglite-dialect-config.js

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

package/dist/dialect/pglite/pglite-dialect.d.ts

@@ -0,0 +1,55 @@
+import type { Driver } from '../../driver/driver.js';
+import type { Kysely } from '../../kysely.js';
+import type { QueryCompiler } from '../../query-compiler/query-compiler.js';
+import type { DatabaseIntrospector } from '../database-introspector.js';
+import type { DialectAdapter } from '../dialect-adapter.js';
+import type { Dialect } from '../dialect.js';
+import type { PGliteDialectConfig } from './pglite-dialect-config.js';
+/**
+ * PGlite dialect.
+ *
+ * The constructor takes an instance of {@link PGliteDialectConfig}.
+ *
+ * ```ts
+ * import { PGlite } from '@electric-sql/pglite'
+ *
+ * new PGliteDialect({
+ *   pglite: new PGlite()
+ * })
+ * ```
+ *
+ * If you want the client to only be created once it's first used, `pglite`
+ * can be a function:
+ *
+ * ```ts
+ * import { PGlite } from '@electric-sql/pglite'
+ *
+ * new PGliteDialect({
+ *   pglite: () => new PGlite()
+ * })
+ * ```
+ */
+export declare class PGliteDialect implements Dialect {
+    #private;
+    constructor(config: PGliteDialectConfig);
+    /**
+     * Creates an adapter for the dialect.
+     */
+    createAdapter(): DialectAdapter;
+    /**
+     * Creates a driver for the dialect.
+     */
+    createDriver(): Driver;
+    /**
+     * Creates a database introspector that can be used to get database metadata
+     * such as the table names and column names of those tables.
+     *
+     * `db` never has any plugins installed. It's created using
+     * {@link Kysely.withoutPlugins}.
+     */
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+    /**
+     * Creates a query compiler for the dialect.
+     */
+    createQueryCompiler(): QueryCompiler;
+}