import { DatabaseConnection, DatabaseIntrospector, DefaultQueryCompiler, Dialect, DialectAdapter, Driver, Kysely, QueryCompiler, RawBuilder, Simplify } from "kysely";
import * as duckdb from "@duckdb/duckdb-wasm";

//#region src/driver-wasm.d.ts
interface DuckDbWasmDriverConfig {
  database: (() => Promise<duckdb.AsyncDuckDB>) | duckdb.AsyncDuckDB;
  onCreateConnection?: (connection: duckdb.AsyncDuckDBConnection) => Promise<void>;
}
declare class DuckDbWasmDriver implements Driver {
  #private;
  constructor(config: DuckDbWasmDriverConfig);
  init(): Promise<void>;
  acquireConnection(): Promise<DatabaseConnection>;
  beginTransaction(connection: DatabaseConnection): Promise<void>;
  commitTransaction(connection: DatabaseConnection): Promise<void>;
  rollbackTransaction(connection: DatabaseConnection): Promise<void>;
  releaseConnection(connection: DatabaseConnection): Promise<void>;
  destroy(): Promise<void>;
}
//#endregion
//#region src/query-compiler.d.ts
interface DuckDbQueryCompilerConfigs {
  /**
   * Mappings of table name in kysely to duckdb table expressions.
   *
   * Duckdb can read external source(file, url or database) as table
   * like: `SELECT * FROM read_json_objects('path/to/file/*.json')`.
   * You can use raw duckdb table expression as table name, but it may be too
   * long, preserving too many implementation details.
   *
   * This mappings is used to replace table name string to duckdb table expression.
   *
   * @example
   * ```ts
   * const dialect = new DuckDbDialect({
   *  database: db,
   *  tableMappings: {
   *    person: 'read_json_object("s3://my-bucket/person.json?s3_access_key_id=key&s3_secret_access_key=secret")'
   *  }
   * });
   *
   * const db = new Kysely<{
   *   person: { first_name: string, last_name: string }, // 'person' is defined in tableMappings
   *   pet: { name: string, species: 'cat' | 'dog' },     // 'pet' is *not* defined in tableMappings
   * >({ dialect });
   *
   * await db.selectFrom("person").selectAll().execute();
   * // => Executed query is: `SELECT * FROM read_json_object("s3://my-bucket/person.json?s3_access_key_id=key&s3_secret_access_key=secret");`
   * ```
   *
   * await db.selectFrom("pet").selectAll().execute();
   * // => Executed query is: `SELECT * FROM pet;`
   */
  tableMappings: {
    [tableName: string]: string;
  };
}
declare namespace datatypes_d_exports {
  export { DuckDBWasmDataTypes, bit, blob, date, list, map, struct, timestamp, timestamptz };
}
type DuckDBWasmDataTypes = {
  BIT: string;
  BLOB: ArrayBufferLike;
  BOOLEAN: boolean;
  DATE: Date;
  ENUM: string;
  INTERVAL: {
    months: number;
    days: number;
    micros: number;
  };
  TINYINT: number;
  INT1: number;
  SMALLINT: number;
  INT2: number;
  SHORT: number;
  INTEGER: number;
  INT4: number;
  INT: number;
  SIGNED: number;
  BIGINT: number;
  INT8: number;
  LONG: number;
  HUGEINT: number;
  UTINYINT: number;
  USMALLINT: number;
  UINTEGER: number;
  UBIGINT: number;
  VARCHAR: string;
  CHAR: string;
  BPCHAR: string;
  TEXT: string;
  STRING: string;
  MAP: string;
  TIMESTAMP: Date;
  DATETIME: Date;
  TIMESTAMPTZ: Date;
  TIMESTAMP_WITH_TIME_ZONE: Date;
};
declare const bit: (value: string) => RawBuilder<string>;
declare const blob: (buf: Uint8Array | ArrayBufferLike | number[]) => RawBuilder<ArrayBufferLike>;
declare const date: (date: Date) => RawBuilder<Date>;
declare const list: <T>(values: T[]) => RawBuilder<any[]>;
declare const map: <K, V>(values: [K, V][]) => RawBuilder<any>;
declare const struct: (values: Record<string, RawBuilder<any> | unknown>) => RawBuilder<any>;
declare const timestamp: <T extends Date | string>(value: T) => RawBuilder<T>;
declare const timestamptz: <T extends Date | string>(value: T) => RawBuilder<Date>;
//#endregion
//#region src/index.d.ts
type DuckDbDialectConfig = Simplify<DuckDbWasmDriverConfig & DuckDbQueryCompilerConfigs>;
/**
 * Kysely dialect for duckdb.
 *
 * ## Quick Start and Usage Example
 * Please see also [Kysely Docs](https://kysely.dev/docs/intro) and [Duckdb Docs](https://duckdb.org/docs/)
 *
 * ### Install
 * ```bash
 * $ npm install --save kysely @duckdb/duckdb-wasm @coji/kysely-duckdb-wasm
 * ```
 *
 * ### Basic Usage Example
 * reading data from json file.
 * ```ts
 * import * as duckdb from "@duckdb/duckdb-wasm";
 * import { Kysely } from "kysely";
 * import { DuckDbDialect } from "@coji/kysely-duckdb-wasm";
 *
 * interface PersonTable {
 *   first_name: string,
 *   gender: string,
 *   last_name: string,
 * };
 * interface DatabaseSchema {
 *   person: PersonTable,
 * };
 *
 * const worker = new Worker('@duckdb/duckdb-wasm/dist/duckdb-browser-eh.worker.js');
 * const logger = new duckdb.ConsoleLogger(duckdb.LogLevel.ERROR);
 * const db = new duckdb.AsyncDuckDB(logger, worker);
 * await db.instantiate('@duckdb/duckdb-wasm/dist/duckdb-eh.wasm');
 * const duckdbDialect = new DuckDbDialect({
 *   database: db,
 *   tableMappings: {
 *     person:
 *       `read_json('./person.json', columns={"first_name": "STRING", "gender": "STRING", "last_name": "STRING"})`,
 *   },
 * });
 * const kysely = new Kysely<DatabaseSchema>({ dialect: duckdbDialect });
 *
 * const res = await kysely.selectFrom("person").selectAll().execute();
 * ```
 */
declare class DuckDbDialect implements Dialect {
  private readonly config;
  /**
   * @param config configurations for DuckDbDialect
   */
  constructor(config: DuckDbDialectConfig);
  createQueryCompiler(): QueryCompiler;
  createIntrospector(db: Kysely<any>): DatabaseIntrospector;
  createDriver(): Driver;
  createAdapter(): DialectAdapter;
}
//#endregion
export { type DuckDBWasmDataTypes, DuckDbDialect, DuckDbDialectConfig, DuckDbWasmDriver, type DuckDbWasmDriverConfig, datatypes_d_exports as datatypes };
//# sourceMappingURL=index.d.ts.map