kysely 0.28.17 → 0.29.0

package/dist/esm/dialect/mssql/mssql-driver.js

@@ -1,356 +0,0 @@
-/// <reference types="./mssql-driver.d.ts" />
-import { freeze, isBigInt, isBoolean, isBuffer, isDate, isNull, isNumber, isString, isUndefined, } from '../../util/object-utils.js';
-import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { extendStackTrace } from '../../util/stack-trace-utils.js';
-import { randomString } from '../../util/random-string.js';
-import { Deferred } from '../../util/deferred.js';
-const PRIVATE_RESET_METHOD = Symbol();
-const PRIVATE_DESTROY_METHOD = Symbol();
-const PRIVATE_VALIDATE_METHOD = Symbol();
-export class MssqlDriver {
-    #config;
-    #pool;
-    constructor(config) {
-        this.#config = freeze({ ...config });
-        const { tarn, tedious, validateConnections } = this.#config;
-        const { validateConnections: deprecatedValidateConnections, ...poolOptions } = tarn.options;
-        this.#pool = new tarn.Pool({
-            ...poolOptions,
-            create: async () => {
-                const connection = await tedious.connectionFactory();
-                return await new MssqlConnection(connection, tedious).connect();
-            },
-            destroy: async (connection) => {
-                await connection[PRIVATE_DESTROY_METHOD]();
-            },
-            // @ts-ignore `tarn` accepts a function that returns a promise here, but
-            // the types are not aligned and it type errors.
-            validate: validateConnections === false ||
-                deprecatedValidateConnections === false
-                ? undefined
-                : (connection) => connection[PRIVATE_VALIDATE_METHOD](),
-        });
-    }
-    async init() {
-        // noop
-    }
-    async acquireConnection() {
-        return await this.#pool.acquire().promise;
-    }
-    async beginTransaction(connection, settings) {
-        await connection.beginTransaction(settings);
-    }
-    async commitTransaction(connection) {
-        await connection.commitTransaction();
-    }
-    async rollbackTransaction(connection) {
-        await connection.rollbackTransaction();
-    }
-    async savepoint(connection, savepointName) {
-        await connection.savepoint(savepointName);
-    }
-    async rollbackToSavepoint(connection, savepointName) {
-        await connection.rollbackTransaction(savepointName);
-    }
-    async releaseConnection(connection) {
-        if (this.#config.resetConnectionsOnRelease ||
-            this.#config.tedious.resetConnectionOnRelease) {
-            await connection[PRIVATE_RESET_METHOD]();
-        }
-        this.#pool.release(connection);
-    }
-    async destroy() {
-        await this.#pool.destroy();
-    }
-}
-class MssqlConnection {
-    #connection;
-    #hasSocketError;
-    #tedious;
-    constructor(connection, tedious) {
-        this.#connection = connection;
-        this.#hasSocketError = false;
-        this.#tedious = tedious;
-    }
-    async beginTransaction(settings) {
-        const { isolationLevel } = settings;
-        await new Promise((resolve, reject) => this.#connection.beginTransaction((error) => {
-            if (error)
-                reject(error);
-            else
-                resolve(undefined);
-        }, isolationLevel ? randomString(8) : undefined, isolationLevel
-            ? this.#getTediousIsolationLevel(isolationLevel)
-            : undefined));
-    }
-    async commitTransaction() {
-        await new Promise((resolve, reject) => this.#connection.commitTransaction((error) => {
-            if (error)
-                reject(error);
-            else
-                resolve(undefined);
-        }));
-    }
-    async connect() {
-        const { promise: waitForConnected, reject, resolve } = new Deferred();
-        this.#connection.connect((error) => {
-            if (error) {
-                return reject(error);
-            }
-            resolve();
-        });
-        this.#connection.on('error', (error) => {
-            if (error instanceof Error &&
-                'code' in error &&
-                error.code === 'ESOCKET') {
-                this.#hasSocketError = true;
-            }
-            console.error(error);
-            reject(error);
-        });
-        function endListener() {
-            reject(new Error('The connection ended without ever completing the connection'));
-        }
-        this.#connection.once('end', endListener);
-        await waitForConnected;
-        this.#connection.off('end', endListener);
-        return this;
-    }
-    async executeQuery(compiledQuery) {
-        try {
-            const deferred = new Deferred();
-            const request = new MssqlRequest({
-                compiledQuery,
-                tedious: this.#tedious,
-                onDone: deferred,
-            });
-            this.#connection.execSql(request.request);
-            const { rowCount, rows } = await deferred.promise;
-            return {
-                numAffectedRows: rowCount !== undefined ? BigInt(rowCount) : undefined,
-                rows,
-            };
-        }
-        catch (err) {
-            throw extendStackTrace(err, new Error());
-        }
-    }
-    async rollbackTransaction(savepointName) {
-        await new Promise((resolve, reject) => this.#connection.rollbackTransaction((error) => {
-            if (error)
-                reject(error);
-            else
-                resolve(undefined);
-        }, savepointName));
-    }
-    async savepoint(savepointName) {
-        await new Promise((resolve, reject) => this.#connection.saveTransaction((error) => {
-            if (error)
-                reject(error);
-            else
-                resolve(undefined);
-        }, savepointName));
-    }
-    async *streamQuery(compiledQuery, chunkSize) {
-        if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
-            throw new Error('chunkSize must be a positive integer');
-        }
-        const request = new MssqlRequest({
-            compiledQuery,
-            streamChunkSize: chunkSize,
-            tedious: this.#tedious,
-        });
-        this.#connection.execSql(request.request);
-        try {
-            while (true) {
-                const rows = await request.readChunk();
-                if (rows.length === 0) {
-                    break;
-                }
-                yield { rows };
-                if (rows.length < chunkSize) {
-                    break;
-                }
-            }
-        }
-        finally {
-            await this.#cancelRequest(request);
-        }
-    }
-    #getTediousIsolationLevel(isolationLevel) {
-        const { ISOLATION_LEVEL } = this.#tedious;
-        const mapper = {
-            'read committed': ISOLATION_LEVEL.READ_COMMITTED,
-            'read uncommitted': ISOLATION_LEVEL.READ_UNCOMMITTED,
-            'repeatable read': ISOLATION_LEVEL.REPEATABLE_READ,
-            serializable: ISOLATION_LEVEL.SERIALIZABLE,
-            snapshot: ISOLATION_LEVEL.SNAPSHOT,
-        };
-        const tediousIsolationLevel = mapper[isolationLevel];
-        if (tediousIsolationLevel === undefined) {
-            throw new Error(`Unknown isolation level: ${isolationLevel}`);
-        }
-        return tediousIsolationLevel;
-    }
-    #cancelRequest(request) {
-        return new Promise((resolve) => {
-            request.request.once('requestCompleted', resolve);
-            const wasCanceled = this.#connection.cancel();
-            if (!wasCanceled) {
-                request.request.off('requestCompleted', resolve);
-                resolve();
-            }
-        });
-    }
-    [PRIVATE_DESTROY_METHOD]() {
-        if ('closed' in this.#connection && this.#connection.closed) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-            this.#connection.once('end', resolve);
-            this.#connection.close();
-        });
-    }
-    async [PRIVATE_RESET_METHOD]() {
-        await new Promise((resolve, reject) => {
-            this.#connection.reset((error) => {
-                if (error) {
-                    return reject(error);
-                }
-                resolve();
-            });
-        });
-    }
-    async [PRIVATE_VALIDATE_METHOD]() {
-        if (this.#hasSocketError || this.#isConnectionClosed()) {
-            return false;
-        }
-        try {
-            const deferred = new Deferred();
-            const request = new MssqlRequest({
-                compiledQuery: CompiledQuery.raw('select 1'),
-                onDone: deferred,
-                tedious: this.#tedious,
-            });
-            this.#connection.execSql(request.request);
-            await deferred.promise;
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    #isConnectionClosed() {
-        return 'closed' in this.#connection && Boolean(this.#connection.closed);
-    }
-}
-class MssqlRequest {
-    #request;
-    #rows;
-    #streamChunkSize;
-    #subscribers;
-    #tedious;
-    #rowCount;
-    constructor(props) {
-        const { compiledQuery, onDone, streamChunkSize, tedious } = props;
-        this.#rows = [];
-        this.#streamChunkSize = streamChunkSize;
-        this.#subscribers = {};
-        this.#tedious = tedious;
-        if (onDone) {
-            const subscriptionKey = 'onDone';
-            this.#subscribers[subscriptionKey] = (event, error) => {
-                if (event === 'chunkReady') {
-                    return;
-                }
-                delete this.#subscribers[subscriptionKey];
-                if (event === 'error') {
-                    return onDone.reject(error);
-                }
-                onDone.resolve({
-                    rowCount: this.#rowCount,
-                    rows: this.#rows,
-                });
-            };
-        }
-        this.#request = new this.#tedious.Request(compiledQuery.sql, (err, rowCount) => {
-            if (err) {
-                return Object.values(this.#subscribers).forEach((subscriber) => subscriber('error', err instanceof AggregateError ? err.errors : err));
-            }
-            this.#rowCount = rowCount;
-        });
-        this.#addParametersToRequest(compiledQuery.parameters);
-        this.#attachListeners();
-    }
-    get request() {
-        return this.#request;
-    }
-    readChunk() {
-        const subscriptionKey = this.readChunk.name;
-        return new Promise((resolve, reject) => {
-            this.#subscribers[subscriptionKey] = (event, error) => {
-                delete this.#subscribers[subscriptionKey];
-                if (event === 'error') {
-                    return reject(error);
-                }
-                resolve(this.#rows.splice(0, this.#streamChunkSize));
-            };
-            this.#request.resume();
-        });
-    }
-    #addParametersToRequest(parameters) {
-        for (let i = 0; i < parameters.length; i++) {
-            const parameter = parameters[i];
-            this.#request.addParameter(String(i + 1), this.#getTediousDataType(parameter), parameter);
-        }
-    }
-    #attachListeners() {
-        const pauseAndEmitChunkReady = this.#streamChunkSize
-            ? () => {
-                if (this.#streamChunkSize <= this.#rows.length) {
-                    this.#request.pause();
-                    Object.values(this.#subscribers).forEach((subscriber) => subscriber('chunkReady'));
-                }
-            }
-            : () => { };
-        const rowListener = (columns) => {
-            const row = {};
-            for (const column of columns) {
-                row[column.metadata.colName] = column.value;
-            }
-            this.#rows.push(row);
-            pauseAndEmitChunkReady();
-        };
-        this.#request.on('row', rowListener);
-        this.#request.once('requestCompleted', () => {
-            Object.values(this.#subscribers).forEach((subscriber) => subscriber('completed'));
-            this.#request.off('row', rowListener);
-        });
-    }
-    #getTediousDataType(value) {
-        if (isNull(value) || isUndefined(value) || isString(value)) {
-            return this.#tedious.TYPES.NVarChar;
-        }
-        if (isBigInt(value) || (isNumber(value) && value % 1 === 0)) {
-            if (value < -2147483648 || value > 2147483647) {
-                return this.#tedious.TYPES.BigInt;
-            }
-            else {
-                return this.#tedious.TYPES.Int;
-            }
-        }
-        if (isNumber(value)) {
-            return this.#tedious.TYPES.Float;
-        }
-        if (isBoolean(value)) {
-            return this.#tedious.TYPES.Bit;
-        }
-        if (isDate(value)) {
-            return this.#tedious.TYPES.DateTime;
-        }
-        if (isBuffer(value)) {
-            return this.#tedious.TYPES.VarBinary;
-        }
-        return this.#tedious.TYPES.NVarChar;
-    }
-}

package/dist/esm/dialect/mssql/mssql-introspector.d.ts

@@ -1,20 +0,0 @@
-import type { Kysely } from '../../kysely.js';
-import type { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
-export declare class MssqlIntrospector implements DatabaseIntrospector {
-    #private;
-    constructor(db: Kysely<any>);
-    /**
-     * Get schema metadata.
-     */
-    getSchemas(): Promise<SchemaMetadata[]>;
-    /**
-     * Get tables and views metadata.
-     */
-    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
-    /**
-     * Get the database metadata such as table and column names.
-     *
-     * @deprecated Use getTables() instead.
-     */
-    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
-}

package/dist/esm/dialect/mssql/mssql-introspector.js

@@ -1,107 +0,0 @@
-/// <reference types="./mssql-introspector.d.ts" />
-import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
-import { freeze } from '../../util/object-utils.js';
-export class MssqlIntrospector {
-    #db;
-    constructor(db) {
-        this.#db = db;
-    }
-    async getSchemas() {
-        return await this.#db.selectFrom('sys.schemas').select('name').execute();
-    }
-    async getTables(options = { withInternalKyselyTables: false }) {
-        const rawColumns = await this.#db
-            .selectFrom('sys.tables as tables')
-            .leftJoin('sys.schemas as table_schemas', 'table_schemas.schema_id', 'tables.schema_id')
-            .innerJoin('sys.columns as columns', 'columns.object_id', 'tables.object_id')
-            .innerJoin('sys.types as types', 'types.user_type_id', 'columns.user_type_id')
-            .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
-            .leftJoin('sys.extended_properties as comments', (join) => join
-            .onRef('comments.major_id', '=', 'tables.object_id')
-            .onRef('comments.minor_id', '=', 'columns.column_id')
-            .on('comments.name', '=', 'MS_Description'))
-            .$if(!options.withInternalKyselyTables, (qb) => qb
-            .where('tables.name', '!=', DEFAULT_MIGRATION_TABLE)
-            .where('tables.name', '!=', DEFAULT_MIGRATION_LOCK_TABLE))
-            .select([
-            'tables.name as table_name',
-            (eb) => eb
-                .ref('tables.type')
-                .$castTo()
-                .as('table_type'),
-            'table_schemas.name as table_schema_name',
-            'columns.default_object_id as column_default_object_id',
-            'columns.generated_always_type_desc as column_generated_always_type',
-            'columns.is_computed as column_is_computed',
-            'columns.is_identity as column_is_identity',
-            'columns.is_nullable as column_is_nullable',
-            'columns.is_rowguidcol as column_is_rowguidcol',
-            'columns.name as column_name',
-            'types.is_nullable as type_is_nullable',
-            'types.name as type_name',
-            'type_schemas.name as type_schema_name',
-            'comments.value as column_comment',
-        ])
-            .unionAll(this.#db
-            .selectFrom('sys.views as views')
-            .leftJoin('sys.schemas as view_schemas', 'view_schemas.schema_id', 'views.schema_id')
-            .innerJoin('sys.columns as columns', 'columns.object_id', 'views.object_id')
-            .innerJoin('sys.types as types', 'types.user_type_id', 'columns.user_type_id')
-            .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
-            .leftJoin('sys.extended_properties as comments', (join) => join
-            .onRef('comments.major_id', '=', 'views.object_id')
-            .onRef('comments.minor_id', '=', 'columns.column_id')
-            .on('comments.name', '=', 'MS_Description'))
-            .select([
-            'views.name as table_name',
-            'views.type as table_type',
-            'view_schemas.name as table_schema_name',
-            'columns.default_object_id as column_default_object_id',
-            'columns.generated_always_type_desc as column_generated_always_type',
-            'columns.is_computed as column_is_computed',
-            'columns.is_identity as column_is_identity',
-            'columns.is_nullable as column_is_nullable',
-            'columns.is_rowguidcol as column_is_rowguidcol',
-            'columns.name as column_name',
-            'types.is_nullable as type_is_nullable',
-            'types.name as type_name',
-            'type_schemas.name as type_schema_name',
-            'comments.value as column_comment',
-        ]))
-            .orderBy('table_schema_name')
-            .orderBy('table_name')
-            .orderBy('column_name')
-            .execute();
-        const tableDictionary = {};
-        for (const rawColumn of rawColumns) {
-            const key = `${rawColumn.table_schema_name}.${rawColumn.table_name}`;
-            const table = (tableDictionary[key] =
-                tableDictionary[key] ||
-                    freeze({
-                        columns: [],
-                        isView: rawColumn.table_type === 'V ',
-                        name: rawColumn.table_name,
-                        schema: rawColumn.table_schema_name ?? undefined,
-                    }));
-            table.columns.push(freeze({
-                dataType: rawColumn.type_name,
-                dataTypeSchema: rawColumn.type_schema_name ?? undefined,
-                hasDefaultValue: rawColumn.column_default_object_id > 0 ||
-                    rawColumn.column_generated_always_type !== 'NOT_APPLICABLE' ||
-                    rawColumn.column_is_identity ||
-                    rawColumn.column_is_computed ||
-                    rawColumn.column_is_rowguidcol,
-                isAutoIncrementing: rawColumn.column_is_identity,
-                isNullable: rawColumn.column_is_nullable && rawColumn.type_is_nullable,
-                name: rawColumn.column_name,
-                comment: rawColumn.column_comment ?? undefined,
-            }));
-        }
-        return Object.values(tableDictionary);
-    }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
-}

package/dist/esm/dialect/mssql/mssql-query-compiler.d.ts

@@ -1,17 +0,0 @@
-import type { AddColumnNode } from '../../operation-node/add-column-node.js';
-import type { AlterTableColumnAlterationNode } from '../../operation-node/alter-table-node.js';
-import type { DropColumnNode } from '../../operation-node/drop-column-node.js';
-import type { OffsetNode } from '../../operation-node/offset-node.js';
-import type { MergeQueryNode } from '../../operation-node/merge-query-node.js';
-import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
-import type { CollateNode } from '../../operation-node/collate-node.js';
-export declare class MssqlQueryCompiler extends DefaultQueryCompiler {
-    protected getCurrentParameterPlaceholder(): string;
-    protected visitOffset(node: OffsetNode): void;
-    protected compileColumnAlterations(columnAlterations: readonly AlterTableColumnAlterationNode[]): void;
-    protected visitAddColumn(node: AddColumnNode): void;
-    protected visitDropColumn(node: DropColumnNode): void;
-    protected visitMergeQuery(node: MergeQueryNode): void;
-    protected visitCollate(node: CollateNode): void;
-    protected announcesNewColumnDataType(): boolean;
-}

package/dist/esm/dialect/mssql/mssql-query-compiler.js

@@ -1,80 +0,0 @@
-/// <reference types="./mssql-query-compiler.d.ts" />
-import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
-const COLLATION_CHAR_REGEX = /^[a-z0-9_]$/i;
-export class MssqlQueryCompiler extends DefaultQueryCompiler {
-    getCurrentParameterPlaceholder() {
-        return `@${this.numParameters}`;
-    }
-    visitOffset(node) {
-        super.visitOffset(node);
-        this.append(' rows');
-    }
-    // mssql allows multi-column alterations in a single statement,
-    // but you can only use the command keyword/s once.
-    // it also doesn't support multiple kinds of commands in the same
-    // alter table statement, but we compile that anyway for the sake
-    // of WYSIWYG.
-    compileColumnAlterations(columnAlterations) {
-        const nodesByKind = {};
-        for (const columnAlteration of columnAlterations) {
-            if (!nodesByKind[columnAlteration.kind]) {
-                nodesByKind[columnAlteration.kind] = [];
-            }
-            nodesByKind[columnAlteration.kind].push(columnAlteration);
-        }
-        let first = true;
-        if (nodesByKind.AddColumnNode) {
-            this.append('add ');
-            this.compileList(nodesByKind.AddColumnNode);
-            first = false;
-        }
-        // multiple of these are not really supported by mssql,
-        // but for the sake of WYSIWYG.
-        if (nodesByKind.AlterColumnNode) {
-            if (!first)
-                this.append(', ');
-            this.compileList(nodesByKind.AlterColumnNode);
-        }
-        if (nodesByKind.DropColumnNode) {
-            if (!first)
-                this.append(', ');
-            this.append('drop column ');
-            this.compileList(nodesByKind.DropColumnNode);
-        }
-        // not really supported by mssql, but for the sake of WYSIWYG.
-        if (nodesByKind.ModifyColumnNode) {
-            if (!first)
-                this.append(', ');
-            this.compileList(nodesByKind.ModifyColumnNode);
-        }
-        // not really supported by mssql, but for the sake of WYSIWYG.
-        if (nodesByKind.RenameColumnNode) {
-            if (!first)
-                this.append(', ');
-            this.compileList(nodesByKind.RenameColumnNode);
-        }
-    }
-    visitAddColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitDropColumn(node) {
-        this.visitNode(node.column);
-    }
-    visitMergeQuery(node) {
-        super.visitMergeQuery(node);
-        this.append(';');
-    }
-    visitCollate(node) {
-        this.append('collate ');
-        const { name } = node.collation;
-        for (const char of name) {
-            if (!COLLATION_CHAR_REGEX.test(char)) {
-                throw new Error(`Invalid collation: ${name}`);
-            }
-        }
-        this.append(name);
-    }
-    announcesNewColumnDataType() {
-        return false;
-    }
-}

package/dist/esm/dialect/mysql/mysql-adapter.d.ts

@@ -1,80 +0,0 @@
-import type { Kysely } from '../../kysely.js';
-import { DialectAdapterBase } from '../dialect-adapter-base.js';
-import type { MigrationLockOptions } from '../dialect-adapter.js';
-export declare class MysqlAdapter extends DialectAdapterBase {
-    /**
-     * Whether or not this dialect supports transactional DDL.
-     *
-     * If this is true, migrations are executed inside a transaction.
-     */
-    get supportsTransactionalDdl(): boolean;
-    /**
-     * Whether or not this dialect supports the `returning` in inserts
-     * updates and deletes.
-     */
-    get supportsReturning(): 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(db: Kysely<any>, _opt: MigrationLockOptions): 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(db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
-}