kysely 0.28.16 → 0.29.0-rc.0

package/README.md

@@ -1,7 +1,7 @@
 [![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://stand-with-ukraine.pp.ua)
 
 [![NPM Version](https://img.shields.io/npm/v/kysely?style=flat&label=latest)](https://github.com/kysely-org/kysely/releases/latest)
-[![Socket Badge](https://badge.socket.dev/npm/package/kysely/0.28.16)](https://socket.dev/npm/package/kysely/overview/0.28.16)
+[![Socket Badge](https://badge.socket.dev/npm/package/kysely/0.29.0-rc.0)](https://socket.dev/npm/package/kysely/overview/0.29.0-rc.0)
 [![Tests](https://github.com/kysely-org/kysely/actions/workflows/test.yml/badge.svg)](https://github.com/kysely-org/kysely)
 [![License](https://img.shields.io/github/license/kysely-org/kysely?style=flat)](https://github.com/kysely-org/kysely/blob/master/LICENSE)
 [![Issues](https://img.shields.io/github/issues-closed/kysely-org/kysely?logo=github)](https://github.com/kysely-org/kysely/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)
@@ -16,10 +16,11 @@
 [![Bluesky](https://img.shields.io/badge/Bluesky-0285FF?style=flat&logo=Bluesky&logoColor=white)](https://bsky.app/profile/kysely.dev)
 
 ###### Get started
-[![Postgres](https://img.shields.io/badge/postgres-%23316192.svg?style=flat&logo=postgresql&logoColor=white)](https://kysely.dev/docs/getting-started?dialect=postgresql)
-[![MySQL](https://img.shields.io/badge/mysql-4479A1.svg?style=flat&logo=mysql&logoColor=white)](https://kysely.dev/docs/getting-started?dialect=mysql)
-[![MicrosoftSQLServer](https://img.shields.io/badge/Microsoft%20SQL%20Server-CC2927?style=flat&logo=microsoft%20sql%20server&logoColor=white)](https://kysely.dev/docs/getting-started?dialect=mssql)
-[![SQLite](https://img.shields.io/badge/sqlite-%2307405e.svg?style=flat&logo=sqlite&logoColor=white)](https://kysely.dev/docs/getting-started?dialect=sqlite)
+[![PostgreSQL](https://img.shields.io/badge/PostgreSQL-%23316192.svg?style=flat&logo=postgresql&logoColor=white)](https://kysely.dev/docs/getting-started?dialect=postgresql)
+[![MySQL](https://img.shields.io/badge/MySQL-4479A1.svg?style=flat&logo=mysql&logoColor=white)](https://kysely.dev/docs/getting-started?dialect=mysql)
+[![MSSQL](https://img.shields.io/badge/MSSQL-CC2927?style=flat&logo=microsoft%20sql%20server&logoColor=white)](https://kysely.dev/docs/getting-started?dialect=mssql)
+[![SQLite](https://img.shields.io/badge/SQLite-%2307405e.svg?style=flat&logo=sqlite&logoColor=white)](https://kysely.dev/docs/getting-started?dialect=sqlite)
+[![PGlite](https://img.shields.io/badge/PGlite-131517.svg?style=flat&logo=data:image/svg%2bxml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyMDAiIGhlaWdodD0iMTgxIiB2aWV3Qm94PSIwIDAgMzQwIDI3MiIgZmlsbD0ibm9uZSI+CjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNMjg4IDg4LjA1MDdMMjg4IDIxNS45N0MyODggMjIwLjM5MSAyODQuNDEzIDIyMy45NzUgMjc5Ljk5MSAyMjMuOTdMMjQ3Ljk2OCAyMjMuOTMyQzI0My43MzQgMjIzLjkyNyAyNDAuMjcyIDIyMC42MzQgMjM5Ljk5NSAyMTYuNDcxQzIzOS45OTggMjE2LjMxMyAyNDAgMjE2LjE1NSAyNDAgMjE1Ljk5NkwyMzkuOTk5IDE2Ny45OThDMjM5Ljk5OSAxNTQuNzQ0IDIyOS4yMzkgMTQzLjk5OSAyMTUuOTg0IDE0My45OTlDMjAzLjEzOCAxNDMuOTk5IDE5Mi42MzYgMTMzLjkwNiAxOTIgMTIxLjIxN1Y0OC4wMDk1TDI0OC4wMyA0OC4wNTA3QzI3MC4xMDkgNDguMDY2OSAyODggNjUuOTcwOCAyODggODguMDUwN1pNMTI4IDQ3Ljk5ODNMMTI4IDEwNC4wMjNDMTI4IDExNy4yNzcgMTM4Ljc0NSAxMjguMDIzIDE1MiAxMjguMDIzSDE3NkwxNzYgMTI2LjQxNEMxNzYgMTQ0Ljk2MiAxOTEuMDM2IDE1OS45OTggMjA5LjU4NCAxNTkuOTk4QzIxNy41MzMgMTU5Ljk5OCAyMjMuOTc3IDE2Ni40NDIgMjIzLjk3NyAxNzQuMzkxTDIyMy45NzcgMjE1LjkzMkMyMjMuOTc3IDIxNi4xMjMgMjIzLjk4IDIxNi4zMTMgMjIzLjk4NCAyMTYuNTAzQzIyMy43MjIgMjIwLjY4NSAyMjAuMjQ3IDIyMy45OTYgMjE1Ljk5OSAyMjMuOTk2TDE3NS43MjYgMjIzLjk5NEwxNzYgMTY4LjAzNEMxNzYuMDIyIDE2My42MTYgMTcyLjQ1NyAxNjAuMDE3IDE2OC4wMzkgMTU5Ljk5NUMxNjMuNjIxIDE1OS45NzMgMTYwLjAyMiAxNjMuNTM4IDE2MCAxNjcuOTU2TDE1OS43MjYgMjIzLjk1OUwxNTkuNzI2IDIyMy45OTJMMTExLjkgMjIzLjk4OVYxNjcuOTk1QzExMS45IDE2My41NzcgMTA4LjMxOCAxNTkuOTk1IDEwMy45IDE1OS45OTVDOTkuNDgxNiAxNTkuOTk1IDk1Ljg5OTkgMTYzLjU3NyA5NS44OTk5IDE2Ny45OTVWMjIzLjk4OEw1NS45OTk1IDIyMy45ODZDNTEuNTgxNCAyMjMuOTg1IDQ4IDIyMC40MDQgNDggMjE1Ljk4NlY4Ny45OThDNDggNjUuOTA2NiA2NS45MDg3IDQ3Ljk5NzkgODguMDAwMiA0Ny45OThMMTI4IDQ3Ljk5ODNaTTI1Mi4wNCA5Ni4yMTUzQzI1Mi4wNCA4OS41ODc5IDI0Ni42NjcgODQuMjE1MyAyNDAuMDQgODQuMjE1M0MyMzMuNDEyIDg0LjIxNTMgMjI4LjA0IDg5LjU4NzkgMjI4LjA0IDk2LjIxNTNDMjI4LjA0IDEwMi44NDMgMjMzLjQxMiAxMDguMjE1IDI0MC4wNCAxMDguMjE1QzI0Ni42NjcgMTA4LjIxNSAyNTIuMDQgMTAyLjg0MyAyNTIuMDQgOTYuMjE1M1oiIGZpbGw9IiNGNkY5NUMiLz48L3N2Zz4=)](https://kysely.dev/docs/getting-started?dialect=pglite)
 & more!
 
 # [Kysely](https://kysely.dev)

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

@@ -0,0 +1,63 @@
+/**
+ * An interface for getting the database metadata (names of the tables and columns etc.)
+ */
+export interface DatabaseIntrospector {
+    /**
+     * 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>;
+}
+export interface DatabaseMetadataOptions {
+    /**
+     * If this is true, the metadata contains the internal kysely tables
+     * such as the migration tables.
+     */
+    withInternalKyselyTables: boolean;
+}
+export interface SchemaMetadata {
+    readonly name: string;
+}
+export interface DatabaseMetadata {
+    /**
+     * The tables and views found in the database.
+     * The propery isView can be used to tell them apart.
+     */
+    readonly tables: TableMetadata[];
+}
+export interface TableMetadata {
+    readonly name: string;
+    readonly isView: boolean;
+    readonly isForeign: boolean;
+    readonly columns: ColumnMetadata[];
+    readonly schema?: string;
+}
+export interface ColumnMetadata {
+    readonly name: string;
+    /**
+     * The data type of the column as reported by the database.
+     *
+     * NOTE: This value is whatever the database engine returns and it will be
+     *       different on different dialects even if you run the same migrations.
+     *       For example `integer` datatype in a migration will produce `int4`
+     *       on PostgreSQL, `INTEGER` on SQLite and `int` on MySQL.
+     */
+    readonly dataType: string;
+    /**
+     * The schema this column's data type was created in.
+     */
+    readonly dataTypeSchema?: string;
+    readonly isAutoIncrementing: boolean;
+    readonly isNullable: boolean;
+    readonly hasDefaultValue: boolean;
+    readonly comment?: string;
+}

package/dist/dialect/dialect-adapter-base.d.ts

@@ -0,0 +1,79 @@
+import type { Kysely } from '../kysely.js';
+import type { DialectAdapter, MigrationLockOptions } from './dialect-adapter.js';
+/**
+ * A basic implementation of `DialectAdapter` with sensible default values.
+ * Third-party dialects can extend this instead of implementing the `DialectAdapter`
+ * interface from scratch. That way all new settings will get default values when
+ * they are added and there will be less breaking changes.
+ */
+export declare abstract class DialectAdapterBase implements DialectAdapter {
+    get supportsCreateIfNotExists(): boolean;
+    get supportsMultipleConnections(): boolean;
+    get supportsTransactionalDdl(): boolean;
+    get supportsReturning(): boolean;
+    get supportsOutput(): 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.
+     */
+    abstract acquireMigrationLock(db: Kysely<any>, options: 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.
+     */
+    abstract releaseMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
+}

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

@@ -0,0 +1,24 @@
+/// <reference types="./dialect-adapter-base.d.ts" />
+/**
+ * A basic implementation of `DialectAdapter` with sensible default values.
+ * Third-party dialects can extend this instead of implementing the `DialectAdapter`
+ * interface from scratch. That way all new settings will get default values when
+ * they are added and there will be less breaking changes.
+ */
+export class DialectAdapterBase {
+    get supportsCreateIfNotExists() {
+        return true;
+    }
+    get supportsMultipleConnections() {
+        return true;
+    }
+    get supportsTransactionalDdl() {
+        return false;
+    }
+    get supportsReturning() {
+        return false;
+    }
+    get supportsOutput() {
+        return false;
+    }
+}

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

@@ -0,0 +1,131 @@
+import type { Kysely } from '../kysely.js';
+/**
+ * A `DialectAdapter` encapsulates all differences between dialects outside
+ * of `Driver` and `QueryCompiler`.
+ *
+ * For example, some databases support transactional DDL and therefore we want
+ * to run migrations inside a transaction, while other databases don't support
+ * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
+ */
+export interface DialectAdapter {
+    /**
+     * Whether or not this dialect supports `if not exists` in creation of tables/schemas/views/etc.
+     *
+     * Default is `false`.
+     *
+     * If this is false, Kysely's internal migrations tables and schemas are created
+     * without `if not exists` in migrations. This is not a problem if the dialect
+     * supports transactional DDL.
+     */
+    readonly supportsCreateIfNotExists?: boolean;
+    /**
+     * Whether or not this dialect supports multiple connections at the same time.
+     *
+     * Default is `true`.
+     *
+     * If this is false, Kysely will use a single connection for all database operations.
+     */
+    readonly supportsMultipleConnections?: boolean;
+    /**
+     * Whether or not this dialect supports transactional DDL.
+     *
+     * Default is `false`.
+     *
+     * If this is true, migrations are executed inside a transaction.
+     */
+    readonly supportsTransactionalDdl?: boolean;
+    /**
+     * Whether or not this dialect supports the `returning` in inserts
+     * updates and deletes.
+     *
+     * Default is `false`.
+     */
+    readonly supportsReturning?: boolean;
+    /**
+     * Whether or not this dialect supports the `output` clause in inserts
+     * updates and deletes.
+     *
+     * Default is `false`.
+     */
+    readonly supportsOutput?: 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>, options: 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>, options: MigrationLockOptions): Promise<void>;
+}
+export interface MigrationLockOptions {
+    /**
+     * The name of the migration lock table.
+     */
+    readonly lockTable: string;
+    /**
+     * The id of the only row in the migration lock table.
+     */
+    readonly lockRowId: string;
+    /**
+     * The schema in which the migration lock table lives. This is only
+     * defined if the user has specified a custom schema in the migration
+     * settings.
+     */
+    readonly lockTableSchema?: string;
+}

package/dist/dialect/mssql/mssql-adapter.d.ts

@@ -0,0 +1,71 @@
+import type { Kysely } from '../../kysely.js';
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+export declare class MssqlAdapter extends DialectAdapterBase {
+    get supportsCreateIfNotExists(): boolean;
+    get supportsTransactionalDdl(): boolean;
+    get supportsOutput(): 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>): 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/mssql/mssql-driver.d.ts

@@ -0,0 +1,60 @@
+import type { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
+import type { Driver, TransactionSettings } from '../../driver/driver.js';
+import type { MssqlDialectConfig, Tedious, TediousConnection } from './mssql-dialect-config.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+declare const PRIVATE_RESET_METHOD: unique symbol;
+declare const PRIVATE_DESTROY_METHOD: unique symbol;
+declare const PRIVATE_VALIDATE_METHOD: unique symbol;
+export declare class MssqlDriver implements Driver {
+    #private;
+    constructor(config: MssqlDialectConfig);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     */
+    init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(connection: MssqlConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(connection: MssqlConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(connection: MssqlConnection): Promise<void>;
+    savepoint(connection: MssqlConnection, savepointName: string): Promise<void>;
+    rollbackToSavepoint(connection: MssqlConnection, savepointName: string): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(connection: MssqlConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+}
+declare class MssqlConnection implements DatabaseConnection {
+    #private;
+    constructor(connection: TediousConnection, tedious: Tedious);
+    beginTransaction(settings: TransactionSettings): Promise<void>;
+    cancelQuery(): Promise<void>;
+    commitTransaction(): Promise<void>;
+    connect(): Promise<this>;
+    executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    rollbackTransaction(savepointName?: string): Promise<void>;
+    savepoint(savepointName: string): Promise<void>;
+    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
+    [PRIVATE_DESTROY_METHOD](): Promise<void>;
+    [PRIVATE_RESET_METHOD](): Promise<void>;
+    [PRIVATE_VALIDATE_METHOD](): Promise<boolean>;
+}
+export {};