import { CockroachDialect } from "./dialect.cjs";
import { CockroachDatabase } from "./db.cjs";
import { entityKind } from "../entity.cjs";
import * as V1 from "../_relations.cjs";
import { Logger } from "../logger.cjs";
import { PreparedQuery } from "../session.cjs";
import { Query, SQL } from "../sql/index.cjs";

//#region src/cockroach-core/session.d.ts
interface PreparedQueryConfig {
  execute: unknown;
}
declare abstract class CockroachBasePreparedQuery implements PreparedQuery {
  protected query: Query;
  static readonly [entityKind]: string;
  constructor(query: Query);
  getQuery(): Query;
  abstract execute(placeholderValues?: Record<string, unknown>): unknown;
}
declare class CockroachPreparedQuery<T extends PreparedQueryConfig> extends CockroachBasePreparedQuery {
  protected executor: (params?: unknown[]) => Promise<any>;
  readonly mode: 'arrays' | 'objects' | 'raw';
  protected logger: Logger;
  static readonly [entityKind]: string;
  private fastPath;
  constructor(executor: (params?: unknown[]) => Promise<any>, query: Query, mapper: ((rows: any[]) => any) | undefined, mode: 'arrays' | 'objects' | 'raw', logger: Logger);
  execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
}
interface CockroachTransactionConfig {
  isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
  accessMode?: 'read only' | 'read write';
  deferrable?: boolean;
}
declare abstract class CockroachSession<TQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends V1.TablesRelationalConfig = Record<string, never>> {
  protected dialect: CockroachDialect;
  static readonly [entityKind]: string;
  constructor(dialect: CockroachDialect);
  abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, mode: 'arrays' | 'objects' | 'raw', name: string | boolean, mapper?: (rows: any[]) => any): CockroachPreparedQuery<T>;
  execute<T>(query: SQL): Promise<T>;
  arrays<T = unknown>(query: SQL): Promise<T[]>;
  objects<T = unknown>(query: SQL): Promise<T[]>;
  abstract transaction<T>(transaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>, config?: CockroachTransactionConfig): Promise<T>;
}
declare abstract class CockroachTransaction<TQueryResult extends CockroachQueryResultHKT, TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends V1.TablesRelationalConfig = Record<string, never>> extends CockroachDatabase<TQueryResult, TFullSchema, TSchema> {
  protected schema: {
    fullSchema: Record<string, unknown>;
    schema: TSchema;
    tableNamesMap: Record<string, string>;
  } | undefined;
  protected readonly nestedIndex: number;
  static readonly [entityKind]: string;
  constructor(dialect: CockroachDialect, session: CockroachSession<any, any, any>, schema: {
    fullSchema: Record<string, unknown>;
    schema: TSchema;
    tableNamesMap: Record<string, string>;
  } | undefined, nestedIndex?: number);
  rollback(): never;
  setTransaction(config: CockroachTransactionConfig): Promise<void>;
  abstract transaction<T>(transaction: (tx: CockroachTransaction<TQueryResult, TFullSchema, TSchema>) => Promise<T>): Promise<T>;
}
interface CockroachQueryResultHKT {
  readonly $brand: 'CockroachQueryResultHKT';
  readonly row: unknown;
  readonly type: unknown;
}
type CockroachQueryResultKind<TKind extends CockroachQueryResultHKT, TRow> = (TKind & {
  readonly row: TRow;
})['type'];
//#endregion
export { CockroachBasePreparedQuery, CockroachPreparedQuery, CockroachQueryResultHKT, CockroachQueryResultKind, CockroachSession, CockroachTransaction, CockroachTransactionConfig, PreparedQueryConfig };
//# sourceMappingURL=session.d.cts.map